@moda-ai/cli 1.22.1 → 1.23.0

package/dist/init/index.js

@@ -1,1442 +0,0 @@
-// src/init/index.ts. Full moda init wizard orchestrator.
-//
-// Five visible steps: Sign in, Workspace, Plan, Set up, Verify. Every prompt
-// lives in Step 3 (Plan); Step 4 then runs unattended, firing the hosted
-// harness analysis first and overlapping it with the fast local tasks and the
-// SDK integration agent while a live progress board (progress-board.ts)
-// renders each lane.
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { checkbox, confirm, select } from '@inquirer/prompts';
-import { login, loadToken } from '../auth.js';
-import { selectTenantAndCreateKey } from './tenant.js';
-import { detectAgents } from './mcp.js';
-import { installRules } from './rules.js';
-import { initPrompts, runPromptSync } from '../prompts.js';
-import { runSkillSync } from '../skills.js';
-import { SDK_GUIDE_PATH, writeSdkIntegrationGuide } from './sdk-guide.js';
-import { runSdkIntegration } from './sdk-integration.js';
-import { fetchAuditWithApiKey } from './sdk-verification.js';
-import { InitProgressBoard } from './progress-board.js';
-import { createCommandContext } from '../command-context.js';
-import { resolveModaBaseUrl, resolveIngestUrl, VERSION } from '../config.js';
-import { CliAuthError, CliInputError } from '../errors.js';
-import { describeSyncIdentity, describeSyncTenantLabel, detectAvailableCodingAgents, isDeterministicLocalAnalyst, runHarnessCommand, } from '../harness.js';
-import { pollRemoteAnalyzeUntilDone, startRemoteAnalyze, } from '../harness-remote.js';
-import { buildDoctorReport } from '../doctor.js';
-import { renderInitBanner, renderInitComplete, renderInitNote, renderInitSetupPlan, renderInitStep, } from '../tui.js';
-/** Recovery command printed whenever init detaches from a hosted analysis run. */
-const HARNESS_PULL_RECOVERY = 'moda harness pull --sync';
-/** Minimum gap between board-driven progress events per lane in machine modes. */
-const LANE_EVENT_THROTTLE_MS = 2_000;
-export async function runInit(flags, options = {}) {
-    const explicitYes = flags.yes === true ||
-        flags.yes === 'true' ||
-        flags.y === true ||
-        flags.y === 'true';
-    const json = flags.json === true || flags.json === 'true';
-    const agent = flags.agent === true || flags.agent === 'true';
-    const human = !json && !agent;
-    const yes = explicitYes || json || agent;
-    const phases = [];
-    const log = (message) => {
-        if (human)
-            console.log(message);
-    };
-    const warn = (message) => {
-        if (human)
-            console.error(message);
-    };
-    const emit = (phase, message, status) => {
-        options.onEvent?.({ phase, message, status });
-    };
-    // Board-driven lane updates arrive as fast as the underlying stream; machine
-    // modes get them as progress events throttled to one per lane per 2s so
-    // agent NDJSON stays readable (the human board repaints at 150ms instead).
-    const laneEventAt = new Map();
-    const emitLaneProgress = (phase, laneId, message) => {
-        if (!options.onEvent || human)
-            return;
-        const now = Date.now();
-        if (now - (laneEventAt.get(laneId) ?? 0) < LANE_EVENT_THROTTLE_MS)
-            return;
-        laneEventAt.set(laneId, now);
-        emit(phase, message);
-    };
-    log(renderInitBanner());
-    emit('welcome', 'Onboarding this project as a Moda agent harness.', 'completed');
-    phases.push({ id: 'welcome', title: 'Welcome', status: 'completed' });
-    // Step 1: Sign in.
-    // Every auth touchpoint below (cached-token check, browser login, tenant
-    // setup) must share the same --profile context, or `moda init --profile X`
-    // logs in / stores under the default profile while the rest of init reads
-    // from X, and the session then looks unauthenticated or uses the wrong key.
-    const profile = stringFlag(flags.profile);
-    log(renderInitStep(1, 5, 'Sign in', 'No environment variable files are written. File changes are listed before completion.'));
-    let token = loadToken({ profile });
-    if (!token) {
-        if (json || agent) {
-            throw new CliAuthError('Browser authentication is required before non-interactive init can continue.', {
-                reason: 'no_stored_credentials',
-                login_command: ['moda', 'auth', 'login'],
-                resume_command: ['moda', 'init', ...resumeFlagsForInit(flags)],
-            }, 'Run `moda auth login`, then re-run `moda init`.');
-        }
-        let action = 'login';
-        if (!yes) {
-            action = await select({
-                message: 'Get started',
-                choices: [
-                    { name: 'Sign up', value: 'signup' },
-                    { name: 'Login', value: 'login' },
-                ],
-            });
-        }
-        log(renderInitNote(`Opening browser to ${action === 'signup' ? 'sign up' : 'log in'}...`, 'warning'));
-        emit('auth', `Opening browser to ${action}.`);
-        token = await login(action, { profile });
-        log(renderInitNote('Authentication successful'));
-    }
-    else {
-        log(renderInitNote('Already authenticated (cached token)'));
-    }
-    emit('auth', 'Authentication complete.', 'completed');
-    phases.push({ id: 'auth', title: 'Sign in', status: 'completed' });
-    // Step 2: Workspace (tenant + API key).
-    log(renderInitStep(2, 5, 'Workspace'));
-    emit('workspace', 'Selecting workspace and creating API key.');
-    // --tenant-id flag wins over MODA_TENANT_ID; the source drives the
-    // env-shadow warning so we don't warn when the env var was the selection.
-    const tenantIdFlag = stringFlag(flagValue(flags, 'tenant-id', 'tenant_id'));
-    // Normalize the env var the same way as the flag: an empty/whitespace
-    // MODA_TENANT_ID (e.g. `export MODA_TENANT_ID=`, or a harness that blanks it
-    // to clear an inherited value) means "unset", not an explicit empty-id
-    // selection; otherwise the exact-id match below fails with
-    // "No organization with id ''" instead of auto-selecting a sole org.
-    const tenantIdEnv = stringFlag(process.env.MODA_TENANT_ID);
-    const { apiKey, tenantId: selectedTenantId, tenantName } = await selectTenantAndCreateKey({
-        tenantId: tenantIdFlag ?? tenantIdEnv,
-        tenantIdSource: tenantIdFlag ? 'flag' : tenantIdEnv ? 'env' : undefined,
-        nonInteractive: json || agent,
-        silent: !human,
-        resumeCommand: ['moda', 'init', ...resumeFlagsForInit(flags)],
-        profile,
-    });
-    log(renderInitNote(`Active workspace: ${tenantName}`));
-    emit('workspace', `Active workspace: ${tenantName}`, 'completed');
-    phases.push({ id: 'workspace', title: 'Workspace', status: 'completed', details: tenantName });
-    // Step 3: Plan. Every remaining decision lives in this single prompt beat;
-    // Step 4 then runs unattended with zero prompts. Explicit flags keep
-    // overriding exactly as before, and --yes/--json/--agent never prompt
-    // (optional items default off, snapshot consent implied).
-    log(renderInitStep(3, 5, 'Plan', 'One confirmation covers everything below; setup then runs unattended.'));
-    let remote = resolveHarnessRemote(flags);
-    const remotePinned = hasExplicitRemoteChoice(flags);
-    const sdkFlag = resolveSdkIntegrateFlag(flags);
-    const ciCdFlag = resolveCiCdFlag(flags);
-    const autosyncFlag = resolveAutosyncFlag(flags);
-    const harnessRescanFlag = resolveHarnessRescanFlag(flags);
-    const harnessRescanPaths = parseHarnessRescanPaths(flagValue(flags, 'harness-rescan-paths', 'harness_rescan_paths'));
-    // Passing --harness-rescan-paths alone is an explicit opt-in: scoping the
-    // rescan only makes sense when the workflow is being written.
-    const harnessRescanChoice = harnessRescanFlag ?? (harnessRescanPaths !== undefined ? true : undefined);
-    // SDK integration installs packages and edits source via a coding agent, so
-    // it defaults ON only when an agent CLI is installed to do the work; it
-    // never runs unattended without an explicit --sdk-integrate.
-    const codingAgentAvailable = detectAvailableCodingAgents().length > 0;
-    let integrateSdk = sdkFlag !== undefined ? sdkFlag : yes ? false : codingAgentAvailable;
-    let configureCiCd = ciCdFlag ?? false;
-    let configureAutosync = autosyncFlag ?? false;
-    let configureHarnessRescan = harnessRescanChoice ?? false;
-    let setupPlan = [];
-    const renderPlan = () => {
-        setupPlan = buildSetupPlan({
-            installHooks: false,
-            integrateSdk,
-            configureCiCd,
-            configureAutosync,
-            configureHarnessRescan,
-            remote,
-        });
-        log(renderInitSetupPlan(setupPlan, { snapshotConsent: remote }));
-    };
-    renderPlan();
-    if (!yes) {
-        const proceed = await confirm({ message: 'Proceed with this plan?', default: true });
-        if (!proceed) {
-            const choices = [];
-            if (sdkFlag === undefined) {
-                choices.push({
-                    name: 'SDK integration via your coding agent (installs packages, edits source)',
-                    value: 'sdk',
-                    checked: integrateSdk,
-                });
-            }
-            if (!remotePinned) {
-                choices.push({
-                    name: "Harness analysis on Moda's servers (uncheck to run a local coding agent analyst)",
-                    value: 'remote',
-                    checked: remote,
-                });
-            }
-            if (ciCdFlag === undefined) {
-                choices.push({
-                    name: 'CI/CD validation workflow (.github/workflows/moda-validation.yml)',
-                    value: 'ci-cd',
-                    checked: configureCiCd,
-                });
-            }
-            if (autosyncFlag === undefined) {
-                choices.push({
-                    name: 'Autosync prompts and skills on push to main (.github/workflows/moda-autosync.yml)',
-                    value: 'autosync',
-                    checked: configureAutosync,
-                });
-            }
-            if (harnessRescanChoice === undefined) {
-                choices.push({
-                    name: 'Re-scan the harness on push to main (.github/workflows/moda-harness-rescan.yml)',
-                    value: 'harness-rescan',
-                    checked: configureHarnessRescan,
-                });
-            }
-            if (choices.length > 0) {
-                const selected = await checkbox({
-                    message: 'Choose what runs (space toggles, enter confirms)',
-                    choices,
-                });
-                if (sdkFlag === undefined)
-                    integrateSdk = selected.includes('sdk');
-                if (!remotePinned)
-                    remote = selected.includes('remote');
-                if (ciCdFlag === undefined)
-                    configureCiCd = selected.includes('ci-cd');
-                if (autosyncFlag === undefined)
-                    configureAutosync = selected.includes('autosync');
-                if (harnessRescanChoice === undefined)
-                    configureHarnessRescan = selected.includes('harness-rescan');
-                renderPlan();
-            }
-        }
-    }
-    if (json || agent) {
-        const skipped = setupPlan
-            .filter((action) => (action.category === 'sdk' || action.category === 'ci-cd' || action.category === 'autosync' ||
-            action.category === 'harness-rescan') &&
-            action.approved === false)
-            .map((action) => `${action.category}: ${action.command ?? 'explicit flag required'}`);
-        if (skipped.length > 0) {
-            emit('plan', `Non-interactive init skipped optional actions (${skipped.join('; ')}).`, 'warning');
-        }
-    }
-    emit('plan', 'Setup plan ready.', 'completed');
-    phases.push({ id: 'plan', title: 'Plan', status: 'completed' });
-    // Step 4: Set up. Zero prompts from here on. The hosted harness analysis is
-    // fired FIRST and polled concurrently while the fast local tasks and the SDK
-    // integration agent run; a live progress board renders each lane in human
-    // mode. Local-analyst mode stays sequential (AnalystTui provides its own
-    // live progress).
-    log(renderInitStep(4, 5, 'Set up', remote
-        ? 'Harness analysis runs on Moda while local setup continues. No further input is needed.'
-        : 'Runs unattended. No further input is needed.'));
-    const rootDir = process.cwd();
-    // An explicit --remote pin means "never fall back to a local coding agent".
-    const allowLocalFallback = !isTruthyFlag(flagValue(flags, 'remote'));
-    const nestedHarnessFlags = (extra) => commandFlags({
-        summary: true,
-        // The Step 3 plan confirm covers the broad local read and (for remote)
-        // the snapshot upload, so nested harness commands must never re-prompt.
-        yes: true,
-        json: json || agent,
-        agent,
-        quiet: true,
-        'no-telemetry': true,
-        profile,
-        ...extra,
-    });
-    const runAnalyze = (useRemote) => runHarnessCommand(createCommandContext({
-        command: 'harness',
-        positional: 'analyze',
-        positionals: ['analyze'],
-        flags: nestedHarnessFlags({
-            analyst: stringFlag(flags.analyst) ?? 'auto',
-            // Pass the remote/local decision EXPLICITLY. `commandFlags` drops
-            // `remote: false`, so a bare `remote: useRemote` would leave the child
-            // with no signal and it would re-derive remoteness from
-            // `MODA_HARNESS_REMOTE`, silently overriding `--local` and the
-            // remote-failure fallback. `--no-remote` survives (it's `true`).
-            remote: useRemote ? true : undefined,
-            'no-remote': useRemote ? undefined : true,
-            progress: true,
-        }),
-    }));
-    let board;
-    const startBoard = () => {
-        if (!human)
-            return undefined;
-        board ??= new InitProgressBoard();
-        return board;
-    };
-    const validationFailure = () => new CliInputError('Moda Analyst produced a harness report that did not pass validation.', 'Review .moda/harness-report-validation.json, then rerun `moda init --local --analyst=claude|cursor|codex` or `moda harness analyze --analyst=local-scan --summary`.');
-    let harnessPhase = { id: 'harness', title: 'Harness discovery', status: 'completed' };
-    let harnessDeferred = false;
-    // Upload the cited harness graph so Moda's backend has the understanding,
-    // not just local artifacts. `harness sync --from-report` refuses an
-    // unapproved report, so approve it first. Best-effort: a network blip on
-    // either call must not abort onboarding.
-    const approveAndSyncHarness = async () => {
-        // Quality gate: a result with ZERO runtime agents on a repo that clearly
-        // uses LLM frameworks/providers almost always means discovery failed (bad
-        // snapshot, analyst error), not an agent-free repo. Auto-approving and
-        // syncing it would overwrite the tenant's harness with an empty graph, so
-        // withhold the upload and hand the user the retry commands instead.
-        // The framework/provider evidence is the union of what the discovered
-        // graph self-reports AND a deterministic repo-side dependency scan — a
-        // TOTAL discovery failure (0 agents, 0 frameworks, 0 providers) must not
-        // bypass the gate just because the artifact being judged is empty.
-        const graphSignals = readHarnessQualitySignals(rootDir);
-        const repoSignals = detectRepoLlmSignals(rootDir);
-        const signals = graphSignals
-            ? {
-                runtimeAgents: graphSignals.runtimeAgents,
-                frameworks: [...new Set([...graphSignals.frameworks, ...repoSignals.frameworks])],
-                providers: [...new Set([...graphSignals.providers, ...repoSignals.providers])],
-            }
-            : undefined;
-        if (signals && harnessLooksIncomplete(signals)) {
-            const names = [...signals.frameworks, ...signals.providers].join(', ');
-            const retryCommand = remote
-                ? 'moda harness analyze --remote --summary'
-                : 'moda harness analyze --analyst=claude|cursor|codex --summary';
-            warn(renderInitNote(`Harness discovery found 0 runtime agents, but this repo has LLM framework signals (${names}). ` +
-                'Discovery likely failed, so the result was NOT approved or synced.', 'warning'));
-            warn(`  Retry with \`${retryCommand}\`, then \`moda harness approve --yes && moda harness sync --from-report\`.`);
-            emit('harness', 'Harness discovery found 0 agents despite LLM framework signals; sync withheld.', 'warning');
-            harnessPhase = {
-                id: 'harness',
-                title: 'Harness discovery',
-                status: 'warning',
-                details: '0 agents detected; sync withheld',
-            };
-            return;
-        }
-        // Identity banner: the credential is resolved with the same precedence
-        // the upload uses (MODA_API_KEY env wins) and the tenant comes from the
-        // WINNING KEY itself (or is marked unverified), so a shadowed/stale key
-        // is visible — and never mislabeled — BEFORE the graph lands in the
-        // wrong tenant. Best-effort: must not abort onboarding.
-        try {
-            const identity = describeSyncIdentity({ profile, env: process.env });
-            if (identity) {
-                // The friendly workspace name only decorates the id when the winning
-                // key's embedded tenant IS the tenant init just selected — otherwise
-                // the raw (possibly surprising) destination id stands alone.
-                const tenantLabel = identity.tenantSource === 'api-key' && identity.tenantId
-                    ? `${identity.tenantId}${identity.tenantId === selectedTenantId ? ` (${tenantName})` : ''}`
-                    : describeSyncTenantLabel(identity);
-                log(renderInitNote(`Syncing as ${identity.credential} → tenant ${tenantLabel}`, 'info'));
-            }
-        }
-        catch {
-            // Advisory banner only.
-        }
-        try {
-            await runHarnessCommand(createCommandContext({
-                command: 'harness',
-                positional: 'approve',
-                positionals: ['approve'],
-                flags: nestedHarnessFlags({}),
-            }));
-            await runHarnessCommand(createCommandContext({
-                command: 'harness',
-                positional: 'sync',
-                positionals: ['sync'],
-                flags: nestedHarnessFlags({ 'from-report': true }),
-            }));
-            log(renderInitNote('Synced harness graph to Moda'));
-            emit('harness', 'Harness graph synced to Moda.', 'completed');
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            warn(renderInitNote(`Harness sync skipped: ${message}`, 'warning'));
-            warn('  Run `moda harness approve --yes && moda harness sync --from-report` later to upload.');
-            emit('harness', 'Harness sync skipped.', 'warning');
-            harnessPhase = { id: 'harness', title: 'Harness discovery', status: 'warning', details: 'sync skipped' };
-        }
-    };
-    const finishLocalAnalyze = async () => {
-        emit('harness', 'Running Moda Analyst harness discovery.');
-        const result = await runAnalyze(false);
-        if (result.exitCode !== 0)
-            throw validationFailure();
-        log(renderInitNote('Wrote or verified .moda/harness-report.json, .moda/harness.json, and .moda/HARNESS.md'));
-        if (human)
-            printHarnessDetectionSummary();
-        emit('harness', 'Harness discovery complete.', 'completed');
-        await approveAndSyncHarness();
-    };
-    // Fire the hosted analysis first so it overlaps everything below.
-    let pollPromise;
-    let pollError;
-    let remoteRunId;
-    // Covers the whole overlapped window (fast tasks, SDK agent, final await):
-    // a Ctrl-C leaves the hosted run resumable and prints the recovery command.
-    const onRemoteSigint = () => {
-        board?.stop();
-        process.stderr.write(`\nHarness analysis keeps running on Moda. Resume anytime with \`${HARNESS_PULL_RECOVERY}\`.\n`);
-        process.exit(130);
-    };
-    if (remote) {
-        emit('harness', 'Running Moda-hosted harness discovery.');
-        try {
-            const harnessContext = createCommandContext({
-                command: 'harness',
-                positional: 'analyze',
-                positionals: ['analyze'],
-                flags: nestedHarnessFlags({
-                    analyst: stringFlag(flags.analyst) ?? 'auto',
-                    remote: true,
-                }),
-            });
-            const started = await startRemoteAnalyze({ context: harnessContext, rootDir });
-            remoteRunId = started.runId;
-            // From this point Ctrl-C is safe and resumable: the state file already
-            // says `running`, so exiting early just detaches from the hosted run.
-            process.once('SIGINT', onRemoteSigint);
-            emit('harness', `Moda accepted harness analysis run ${started.runId}.`);
-            startBoard()?.startLane('harness', 'Harness analysis on Moda', {
-                detail: 'waiting for the hosted analyst',
-                expectation: 'usually 2-4 min',
-            });
-            pollPromise = pollRemoteAnalyzeUntilDone({
-                context: harnessContext,
-                runId: started.runId,
-                onProgress: ({ status, progress }) => {
-                    if (status === 'completed' || status === 'failed') {
-                        // The hosted run just turned terminal, but the lane is only
-                        // finalized after the SDK lane below. Freeze it now so the board
-                        // does not keep a live spinner and climbing elapsed for minutes
-                        // after the analysis actually finished; the post-setup pull
-                        // refines the note (the board allows terminal refinements).
-                        if (status === 'completed') {
-                            board?.complete('harness', 'analysis finished on Moda; finalizing after setup');
-                        }
-                        else {
-                            board?.warn('harness', 'hosted run finished with issues; finalizing after setup');
-                        }
-                        emitLaneProgress('harness', 'harness', `Hosted analysis ${status}; finalizing after setup.`);
-                        return;
-                    }
-                    const message = progress?.message
-                        ?? (typeof progress?.tool_calls === 'number'
-                            ? `${progress.tool_calls} tool call(s) so far`
-                            : `analysis ${status}`);
-                    board?.update('harness', message);
-                    emitLaneProgress('harness', 'harness', message);
-                },
-            }).catch((error) => {
-                // Captured, not thrown: an unhandled rejection here would crash init
-                // in the middle of the fast tasks. Inspected after the SDK lane.
-                pollError = error;
-                return undefined;
-            });
-        }
-        catch (error) {
-            // A remote failure (service down, upload error) must not sink
-            // onboarding; fall back to the local analyst path unless --remote was
-            // pinned explicitly.
-            if (!allowLocalFallback)
-                throw error;
-            warn(renderInitNote(`Server-side harness discovery unavailable (${error instanceof Error ? error.message : String(error)}); falling back to local analyst.`, 'warning'));
-            emit('harness', 'Server-side discovery failed; falling back to local analyst.', 'warning');
-            remote = false;
-        }
-    }
-    // Local-analyst mode keeps today's sequential behavior: analyze (AnalystTui
-    // renders live progress), then approve + sync, then the fast tasks below.
-    if (!remote) {
-        await finishLocalAnalyze();
-    }
-    emit('apply', 'Applying approved setup changes.');
-    const laneBoard = startBoard();
-    const ingestCodingAgentTraces = false;
-    const agents = detectAgents();
-    laneBoard?.startLane('agent-skills', 'Agent skills');
-    if (agents.length > 0) {
-        // The Step 3 plan already covered the skill install; never re-prompt.
-        await installRules(agents, { yes: true, silent: true });
-        laneBoard?.complete('agent-skills', `moda-cli skill installed for ${agents.join(', ')}`);
-    }
-    else {
-        laneBoard?.complete('agent-skills', 'no coding agents detected');
-    }
-    await initPrompts({ silent: true });
-    laneBoard?.startLane('prompts', 'Prompts', { detail: 'Created or verified .moda/prompts.yml' });
-    // Push the manifest's prompt files to Moda so production traces can attribute
-    // managed prompt versions. A fresh repo has none yet; that's a harmless no-op.
-    try {
-        const promptSync = await runPromptSync({}, { profile });
-        laneBoard?.complete('prompts', promptSync.synced.length > 0
-            ? `${promptSync.synced.length} prompt(s) synced`
-            : 'manifest ready (no prompt files to sync yet)');
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        laneBoard?.warn('prompts', `sync skipped: ${message}`);
-    }
-    // Push locally-authored skills (`.claude/skills/**/SKILL.md`) to Moda, in
-    // parallel intent with prompt sync. Best-effort: a network blip must not
-    // abort onboarding.
-    laneBoard?.startLane('skills', 'Skills');
-    try {
-        const skillSync = await runSkillSync({}, { profile });
-        laneBoard?.complete('skills', skillSync.synced.length > 0
-            ? `${skillSync.synced.length} skill(s) synced`
-            : 'no local skills to sync yet');
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        laneBoard?.warn('skills', `sync skipped: ${message}`);
-    }
-    if (setupPlan.find((action) => action.category === 'ci-cd')?.approved === true) {
-        const workflowPath = writeCiCdWorkflow();
-        laneBoard?.startLane('ci-cd', 'CI/CD workflow');
-        laneBoard?.complete('ci-cd', `wrote ${workflowPath}`);
-        markApplied(setupPlan, 'ci-cd');
-    }
-    if (setupPlan.find((action) => action.category === 'autosync')?.approved === true) {
-        const workflowPath = writeAutosyncWorkflow();
-        laneBoard?.startLane('autosync', 'Autosync workflow');
-        laneBoard?.complete('autosync', `wrote ${workflowPath}`);
-        markApplied(setupPlan, 'autosync');
-    }
-    if (setupPlan.find((action) => action.category === 'harness-rescan')?.approved === true) {
-        const workflowPath = writeHarnessRescanWorkflow(process.cwd(), harnessRescanPaths);
-        laneBoard?.startLane('harness-rescan', 'Harness rescan workflow');
-        laneBoard?.complete('harness-rescan', `wrote ${workflowPath}`);
-        markApplied(setupPlan, 'harness-rescan');
-    }
-    const sdkAction = setupPlan.find((action) => action.category === 'sdk');
-    let sdkIntegration;
-    if (sdkAction?.approved === true) {
-        laneBoard?.startLane('sdk', 'SDK integration', {
-            detail: 'launching your coding agent',
-            expectation: 'usually 3-10 min',
-        });
-        emit('apply', 'Running your coding agent to integrate the Moda SDK.');
-        const verificationBaseUrl = resolveModaBaseUrl({ profile });
-        sdkIntegration = await runSdkIntegration({
-            apiKey,
-            ingestUrl: resolveIngestUrl({ profile }),
-            fetchAudit: (id) => fetchAuditWithApiKey(id, apiKey, verificationBaseUrl),
-            onProgress: (message) => {
-                laneBoard?.update('sdk', message);
-                emitLaneProgress('apply', 'sdk', message);
-            },
-            onPhase: (phase, message) => {
-                laneBoard?.update('sdk', message);
-                emitLaneProgress('apply', 'sdk', message);
-            },
-            // Presence of onEvent selects the streaming agent invocation so tool
-            // cards arrive incrementally; onProgress above receives the rendered
-            // cards (describeCodingAgentEvent), which is all the lane needs.
-            onEvent: () => { },
-        });
-        applySdkIntegrationOutcome(setupPlan, sdkIntegration, {
-            laneBoard,
-            writeGuide: () => writeSdkIntegrationGuide(rootDir),
-        });
-    }
-    else {
-        markApplied(setupPlan, 'sdk', 'User skipped SDK integration.');
-    }
-    markApplied(setupPlan, 'hooks', ingestCodingAgentTraces ? undefined : 'Coding-agent trace capture is temporarily unavailable.');
-    markApplied(setupPlan, 'prompts');
-    markApplied(setupPlan, 'skills');
-    // Await the hosted analysis last: it has been polling concurrently since the
-    // top of this step. Ctrl-C or a poll deadline leaves the run resumable
-    // (state file stays `running`) and prints the pull recovery command.
-    if (remote && pollPromise && remoteRunId) {
-        const final = await pollPromise;
-        process.removeListener('SIGINT', onRemoteSigint);
-        const fallBackToLocal = async (error) => {
-            board?.fail('harness', 'hosted analysis failed');
-            board?.stop();
-            if (!allowLocalFallback)
-                throw error;
-            warn(renderInitNote(`Server-side harness discovery failed (${error instanceof Error ? error.message : String(error)}); falling back to local analyst.`, 'warning'));
-            emit('harness', 'Server-side discovery failed; falling back to local analyst.', 'warning');
-            await finishLocalAnalyze();
-        };
-        if (pollError !== undefined) {
-            await fallBackToLocal(pollError);
-        }
-        else if (!final || (final.status !== 'completed' && final.status !== 'failed')) {
-            // The poll deadline passed while the hosted run kept going. Expected on
-            // very large repos, and safe: the run state file stays `running`.
-            harnessDeferred = true;
-            harnessPhase = { id: 'harness', title: 'Harness discovery', status: 'warning', details: 'still running on Moda' };
-            markApplied(setupPlan, 'harness', `Analysis still running on Moda; run \`${HARNESS_PULL_RECOVERY}\` to fetch and sync it.`);
-            board?.warn('harness', `still running on Moda; run \`${HARNESS_PULL_RECOVERY}\` in a few minutes`);
-            board?.stop();
-            log(renderInitNote(`Harness analysis is still running on Moda. Run \`${HARNESS_PULL_RECOVERY}\` in a few minutes to fetch and sync the result.`, 'info'));
-            emit('harness', `Harness analysis still running on Moda; resume with \`${HARNESS_PULL_RECOVERY}\`.`, 'warning');
-        }
-        else {
-            board?.update('harness', 'writing local artifacts');
-            let pullResult;
-            try {
-                // `harness pull` finalizes exactly like `harness analyze --remote`
-                // (repair, local re-validation, .moda artifact writes) from the
-                // already-terminal hosted run.
-                pullResult = await runHarnessCommand(createCommandContext({
-                    command: 'harness',
-                    positional: 'pull',
-                    positionals: ['pull'],
-                    flags: nestedHarnessFlags({ 'run-id': remoteRunId }),
-                }));
-            }
-            catch (error) {
-                await fallBackToLocal(error);
-            }
-            if (pullResult) {
-                if (pullResult.exitCode !== 0) {
-                    board?.fail('harness', 'report validation failed');
-                    board?.stop();
-                    throw validationFailure();
-                }
-                board?.complete('harness', 'report written to .moda/');
-                board?.stop();
-                log(renderInitNote('Wrote or verified .moda/harness-report.json, .moda/harness.json, and .moda/HARNESS.md'));
-                if (human)
-                    printHarnessDetectionSummary();
-                emit('harness', 'Harness discovery complete.', 'completed');
-                await approveAndSyncHarness();
-            }
-        }
-    }
-    board?.stop();
-    if (!harnessDeferred)
-        markApplied(setupPlan, 'harness');
-    phases.push(harnessPhase);
-    emit('apply', 'Approved changes applied.', 'completed');
-    phases.push({ id: 'apply', title: 'Set up', status: 'completed' });
-    // Step 5: Verify.
-    const offlineValidation = isTruthyFlag(flagValue(flags, 'offline'));
-    log(renderInitStep(5, 5, 'Verify', offlineValidation
-        ? 'Running local doctor checks so the setup leaves a clear state.'
-        : 'Running Moda doctor online as a tenant health check (not proof of SDK integration).'));
-    emit('validate', `Running Moda doctor diagnostics (${offlineValidation ? 'offline' : 'online'}).`);
-    const doctorReport = await buildDoctorReport(createCommandContext({
-        command: 'doctor',
-        positional: undefined,
-        positionals: [],
-        flags: commandFlags({ json: true, quiet: true, 'no-telemetry': true }),
-    }), { offline: offlineValidation });
-    markApplied(setupPlan, 'validation');
-    log(renderInitNote(`Validation checks completed: ${doctorReport.summary.pass} passing, ${doctorReport.summary.warning} warning, ${doctorReport.summary.fail} failing`));
-    let telemetrySeen;
-    if (!offlineValidation) {
-        const cloud = doctorReport.checks.find((check) => check.id === 'cloud_data_flow');
-        if (cloud) {
-            telemetrySeen = cloud.status === 'pass';
-            if (telemetrySeen) {
-                log(renderInitNote('Moda Cloud telemetry: flowing'));
-            }
-            else {
-                // Expected before the app has run with the SDK installed; surfaced as
-                // a next step on the completion screen, not a warning badge.
-                log(renderInitNote('No telemetry yet. Expected until your app runs with the SDK; see next steps.', 'info'));
-            }
-        }
-    }
-    emit('validate', 'Validation checks complete.', doctorReport.summary.fail > 0 ? 'warning' : 'completed');
-    phases.push({ id: 'validate', title: 'Verify', status: 'completed' });
-    // Done: end on the payoff.
-    log(renderInitComplete({
-        tenantName,
-        dashboardUrl: `${resolveModaBaseUrl({ profile })}/dashboard`,
-        harness: harnessDeferred
-            ? { state: 'pending' }
-            : { state: 'mapped', ...readHarnessGraphCounts() },
-        filesChanged: changedFiles(setupPlan),
-        skipped: setupPlan.filter((item) => item.status === 'skipped' || item.status === 'manual'),
-        telemetrySeen,
-    }));
-    return { apiKey, tenantName, phases, setupPlan, ...(sdkIntegration ? { sdk_integration: sdkIntegration } : {}) };
-}
-function buildSetupPlan(options) {
-    return [
-        {
-            category: 'harness',
-            title: options.remote
-                ? "Analyze the harness on Moda's servers, write the cited report, and sync the graph to Moda"
-                : 'Analyze the harness locally, write the cited report, and sync the graph to Moda',
-            status: 'planned',
-            approved: true,
-            files: [
-                '.moda/harness-report.json',
-                '.moda/harness-report-validation.json',
-                '.moda/HARNESS_REPORT.md',
-                '.moda/harness.json',
-                '.moda/HARNESS.md',
-            ],
-            command: options.remote
-                ? 'moda harness analyze --remote --summary && moda harness approve --yes && moda harness sync --from-report'
-                : 'moda harness analyze --analyst=auto --summary && moda harness approve --yes && moda harness sync --from-report',
-        },
-        {
-            category: 'hooks',
-            title: 'Install coding-agent trace hooks',
-            status: options.installHooks ? 'planned' : 'skipped',
-            approved: options.installHooks,
-            files: ['~/.claude/settings.json', '~/.codex/hooks.json', '~/.cursor/hooks.json'],
-            command: 'moda hooks install --agent=all',
-            reason: options.installHooks ? undefined : 'Coding-agent trace capture is temporarily unavailable.',
-        },
-        {
-            category: 'prompts',
-            title: 'Initialize the prompt registry manifest and sync prompts to Moda',
-            status: 'planned',
-            approved: true,
-            files: ['.moda/prompts.yml'],
-            command: 'moda prompts init && moda prompts sync',
-        },
-        {
-            category: 'skills',
-            title: 'Install the moda-cli skill into detected coding agents and sync local skills to Moda',
-            status: 'planned',
-            approved: true,
-            files: ['.claude/skills', '.cursor/rules'],
-            // Skill install into detected agents happens inside `moda init`; there is no
-            // standalone install command, so surface only the re-runnable sync here.
-            command: 'moda skills sync',
-        },
-        {
-            category: 'sdk',
-            title: 'Launch your coding agent to integrate the Moda SDK',
-            status: options.integrateSdk ? 'planned' : 'manual',
-            approved: options.integrateSdk,
-            files: [],
-            command: 'moda init --sdk-integrate',
-            reason: options.integrateSdk
-                ? 'Your agent investigates the repo, applies matching integration skill(s), installs packages, runs repo checks, sends one verification request, and Moda verifies the exact trace. Your Moda API key is provided to the agent\'s environment for the verification run.'
-                : `SDK integration stays manual; see ${SDK_GUIDE_PATH} if you generate the guide.`,
-        },
-        {
-            category: 'ci-cd',
-            title: 'CI/CD validation workflow',
-            status: options.configureCiCd ? 'planned' : 'manual',
-            approved: options.configureCiCd,
-            files: ['.github/workflows/moda-validation.yml'],
-            command: 'moda doctor --online --json',
-            reason: options.configureCiCd ? undefined : 'No CI/CD files are changed until a project-specific plan is approved.',
-        },
-        {
-            category: 'autosync',
-            title: 'Autosync prompts and skills to Moda on push to main',
-            status: options.configureAutosync ? 'planned' : 'manual',
-            approved: options.configureAutosync,
-            files: ['.github/workflows/moda-autosync.yml'],
-            command: 'moda prompts sync && moda skills sync',
-            reason: options.configureAutosync ? undefined : 'No autosync workflow is written until it is explicitly approved (--autosync).',
-        },
-        {
-            category: 'harness-rescan',
-            title: 'Re-scan the harness on push to main so the synced graph never drifts from the code',
-            status: options.configureHarnessRescan ? 'planned' : 'manual',
-            approved: options.configureHarnessRescan,
-            files: ['.github/workflows/moda-harness-rescan.yml'],
-            command: 'moda harness analyze --remote --yes && moda harness approve --yes && moda harness sync --from-report',
-            reason: options.configureHarnessRescan
-                ? undefined
-                : 'No harness rescan workflow is written until it is explicitly approved (--harness-rescan).',
-        },
-        {
-            category: 'validation',
-            title: 'Run Moda doctor online as a tenant health check',
-            status: 'planned',
-            approved: true,
-            files: [],
-            command: 'moda doctor --online',
-        },
-    ];
-}
-function markApplied(setupPlan, category, skipReason) {
-    const action = setupPlan.find((item) => item.category === category);
-    if (!action)
-        return;
-    if (skipReason) {
-        action.status = 'skipped';
-        action.reason = skipReason;
-        return;
-    }
-    if (action.approved)
-        action.status = 'applied';
-}
-function markManual(setupPlan, category, reason) {
-    const action = setupPlan.find((item) => item.category === category);
-    if (!action)
-        return;
-    action.status = 'manual';
-    action.reason = reason;
-}
-function applySdkIntegrationOutcome(setupPlan, outcome, deps) {
-    const sdkAction = setupPlan.find((action) => action.category === 'sdk');
-    if (!sdkAction)
-        return;
-    const { laneBoard, writeGuide } = deps;
-    const verificationId = outcome.verification_id ?? 'unknown';
-    const firstRemaining = outcome.agent_result?.remaining_actions?.[0];
-    switch (outcome.status) {
-        case 'integrated_verified': {
-            const llmSpans = outcome.verification?.llm_spans ?? 0;
-            laneBoard?.complete('sdk', `verified — trace reached Moda (${llmSpans} llm span(s), conversation ${verificationId})`);
-            markApplied(setupPlan, 'sdk');
-            if (outcome.agent_result?.files_changed?.length) {
-                sdkAction.files = [...new Set(outcome.agent_result.files_changed)].slice(0, 20);
-            }
-            break;
-        }
-        case 'telemetry_not_observed':
-            laneBoard?.warn('sdk', `integration applied but the verification trace was not observed; check MODA_API_KEY at runtime, then moda audit ${verificationId}`);
-            markManual(setupPlan, 'sdk', outcome.detail ?? 'Verification trace was not observed.');
-            break;
-        case 'needs_human_input': {
-            const securityLead = outcome.security_findings?.length
-                ? `Security: possible API key leak in ${outcome.security_findings.join(', ')} — remove the key, rotate it, and keep secrets in the environment. `
-                : '';
-            const note = firstRemaining ?? outcome.detail ?? 'Additional human input required.';
-            laneBoard?.warn('sdk', `${securityLead}${note}`);
-            markManual(setupPlan, 'sdk', `${securityLead}${note}`.trim());
-            break;
-        }
-        case 'nothing_to_integrate': {
-            if (outcome.verification?.observed === true) {
-                laneBoard?.complete('sdk', outcome.detail ?? 'existing integration verified — trace reached Moda');
-                markApplied(setupPlan, 'sdk');
-                sdkAction.reason = outcome.detail ?? 'Existing Moda integration verified.';
-                break;
-            }
-            // With a smoke attempt the verification id is real and auditable (the
-            // trace may land late); without one the user must pick their own id.
-            const reason = outcome.verification
-                ? 'agent reports Moda is already integrated but the verification trace was not observed; ' +
-                    `check MODA_API_KEY at runtime, then \`moda audit ${verificationId}\``
-                : 'agent reports Moda is already integrated — not independently verified; ' +
-                    'send a real request through your app with a conversation id you choose, then run `moda audit` with that id';
-            laneBoard?.warn('sdk', reason);
-            markManual(setupPlan, 'sdk', reason);
-            break;
-        }
-        case 'agent_unavailable': {
-            const guidePath = writeGuide();
-            sdkAction.files = [guidePath];
-            laneBoard?.warn('sdk', `no coding agent CLI found; wrote ${guidePath} to integrate by hand`);
-            markManual(setupPlan, 'sdk', `No coding agent CLI found; wrote ${guidePath}.`);
-            break;
-        }
-        case 'cancelled':
-            laneBoard?.fail('sdk', outcome.detail ?? 'SDK integration cancelled');
-            markManual(setupPlan, 'sdk', outcome.detail ?? 'SDK integration cancelled.');
-            break;
-        case 'repository_checks_failed':
-        case 'smoke_execution_failed':
-        case 'agent_failed':
-        default: {
-            const guidePath = writeGuide();
-            sdkAction.files = [guidePath];
-            const detail = outcome.detail ?? 'SDK integration did not complete.';
-            laneBoard?.warn('sdk', `${detail}; wrote ${guidePath} to finish manually`);
-            markManual(setupPlan, 'sdk', `${detail}; wrote ${guidePath}.`);
-            break;
-        }
-    }
-}
-function changedFiles(setupPlan) {
-    return [...new Set(setupPlan
-            .filter((action) => action.status === 'applied')
-            .flatMap((action) => action.files))].filter((file) => !file.includes('.env'));
-}
-// The CLI version generated workflows pin to. Pinning (rather than `@latest`,
-// which resolves at CI run time) keeps a future compromised `@moda-ai/cli`
-// publish from silently executing in adopters' CI with their MODA_API_KEY /
-// MODA_TENANT_ID present. Especially important for autosync, which *writes* to
-// the Moda registry. The pin tracks the CLI that generated the file, so each
-// `moda init` upgrade is an explicit, reviewable bump of the workflow.
-const GENERATED_WORKFLOW_CLI = `@moda-ai/cli@${VERSION}`;
-// npx dispatch shape matters: `npx -y @moda-ai/cli@X moda harness ...` resolves
-// the package's default bin and passes the literal `moda` token through as the
-// CLI's first argument, so every step would exit 1 with "Unknown command
-// 'moda'". `--package=<pkg> moda` pins the package AND names the `moda` bin
-// explicitly, so the CLI receives the real subcommand first.
-const GENERATED_WORKFLOW_NPX = `npx -y --package=${GENERATED_WORKFLOW_CLI} moda`;
-// Exported for tests (generated-workflows.test.ts validates npx dispatch shape).
-export function writeCiCdWorkflow(cwd = process.cwd()) {
-    const relativePath = '.github/workflows/moda-validation.yml';
-    const path = join(cwd, relativePath);
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, `${[
-        'name: Moda Validation',
-        '',
-        'on:',
-        '  pull_request:',
-        '  push:',
-        '    branches: [main]',
-        '',
-        '# Least privilege: these jobs only read the checked-out repo and talk to',
-        '# Moda over the API key; they never write back to the repository.',
-        'permissions:',
-        '  contents: read',
-        '',
-        'jobs:',
-        '  moda-doctor:',
-        '    runs-on: ubuntu-latest',
-        '    env:',
-        '      MODA_API_KEY: ${{ secrets.MODA_API_KEY }}',
-        '      MODA_TENANT_ID: ${{ secrets.MODA_TENANT_ID }}',
-        '    steps:',
-        '      - uses: actions/checkout@v4',
-        '      - uses: actions/setup-node@v4',
-        '        with:',
-        '          node-version: 22',
-        '      - name: Validate Moda setup',
-        `        run: ${GENERATED_WORKFLOW_NPX} doctor --online --json`,
-        '',
-    ].join('\n')}`);
-    return relativePath;
-}
-// Generates a push-to-main autosync workflow that keeps the Moda registry in
-// sync with the repo: it pushes prompt and skill changes after they merge. It
-// only runs on `main` (never on pull_request) so unmerged versions are never
-// published. Keep its env in step with writeCiCdWorkflow().
-export function writeAutosyncWorkflow(cwd = process.cwd()) {
-    const relativePath = '.github/workflows/moda-autosync.yml';
-    const path = join(cwd, relativePath);
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, `${[
-        'name: Moda Autosync',
-        '',
-        'on:',
-        '  push:',
-        '    branches: [main]',
-        '',
-        '# Least privilege: this job only reads the checked-out repo and writes to',
-        '# Moda over the API key; it never writes back to the repository.',
-        'permissions:',
-        '  contents: read',
-        '',
-        '# A single in-flight sync at a time; newer pushes supersede older runs.',
-        'concurrency:',
-        '  group: moda-autosync',
-        '  cancel-in-progress: true',
-        '',
-        'jobs:',
-        '  moda-sync:',
-        '    runs-on: ubuntu-latest',
-        '    env:',
-        '      MODA_API_KEY: ${{ secrets.MODA_API_KEY }}',
-        '      MODA_TENANT_ID: ${{ secrets.MODA_TENANT_ID }}',
-        '    steps:',
-        '      - uses: actions/checkout@v4',
-        '      - uses: actions/setup-node@v4',
-        '        with:',
-        '          node-version: 22',
-        `      - name: Sync prompts to Moda`,
-        `        run: ${GENERATED_WORKFLOW_NPX} prompts sync`,
-        `      - name: Sync skills to Moda`,
-        `        run: ${GENERATED_WORKFLOW_NPX} skills sync`,
-        '',
-    ].join('\n')}`);
-    return relativePath;
-}
-// Generates the "living harness" rescan workflow: after every merge to main
-// the hosted analyst re-analyzes the repo, the refreshed report is approved
-// non-interactively, and the cited graph is synced to Moda — so the harness
-// Moda serves never drifts from the code. It runs only on push to `main`
-// (plus manual workflow_dispatch), never on pull_request, so unmerged agent
-// changes are never synced. An optional path scope limits pushes that trigger
-// a rescan. Keep its env in step with writeCiCdWorkflow().
-export function writeHarnessRescanWorkflow(cwd = process.cwd(), paths) {
-    const relativePath = '.github/workflows/moda-harness-rescan.yml';
-    const path = join(cwd, relativePath);
-    mkdirSync(dirname(path), { recursive: true });
-    const pathScope = paths !== undefined && paths.length > 0
-        ? [
-            '    # Only pushes touching these paths trigger a rescan.',
-            '    paths:',
-            ...paths.map((glob) => `      - '${glob.replace(/'/g, "''")}'`),
-        ]
-        : [
-            '    # Optional: scope rescans to agent-relevant paths, e.g.',
-            '    # paths:',
-            "    #   - 'src/agents/**'",
-        ];
-    writeFileSync(path, `${[
-        'name: Moda Harness Rescan',
-        '',
-        'on:',
-        '  push:',
-        '    branches: [main]',
-        ...pathScope,
-        '  workflow_dispatch:',
-        '',
-        '# Least privilege: this job reads the checked-out repo, uploads a safe',
-        '# source snapshot to Moda over the API key, and syncs the refreshed harness',
-        '# graph; it never writes back to the repository.',
-        'permissions:',
-        '  contents: read',
-        '',
-        '# One in-flight rescan at a time; newer pushes supersede older runs.',
-        'concurrency:',
-        '  group: moda-harness-rescan',
-        '  cancel-in-progress: true',
-        '',
-        'jobs:',
-        '  moda-harness-rescan:',
-        '    runs-on: ubuntu-latest',
-        '    env:',
-        '      MODA_API_KEY: ${{ secrets.MODA_API_KEY }}',
-        '      MODA_TENANT_ID: ${{ secrets.MODA_TENANT_ID }}',
-        '    steps:',
-        '      - uses: actions/checkout@v4',
-        '      - uses: actions/setup-node@v4',
-        '        with:',
-        '          node-version: 22',
-        '      - name: Re-analyze the harness on Moda',
-        `        run: ${GENERATED_WORKFLOW_NPX} harness analyze --remote --yes`,
-        '      - name: Approve the refreshed harness report',
-        `        run: ${GENERATED_WORKFLOW_NPX} harness approve --yes`,
-        '      - name: Sync the harness graph to Moda',
-        `        run: ${GENERATED_WORKFLOW_NPX} harness sync --from-report`,
-        '',
-    ].join('\n')}`);
-    return relativePath;
-}
-function printHarnessDetectionSummary(cwd = process.cwd()) {
-    const manifestPath = join(cwd, '.moda', 'harness.json');
-    if (!existsSync(manifestPath))
-        return;
-    try {
-        const graph = JSON.parse(readFileSync(manifestPath, 'utf8'));
-        const frameworkNames = (graph.agentFrameworks ?? [])
-            .map((framework) => typeof framework.name === 'string' ? framework.name : undefined)
-            .filter((name) => Boolean(name));
-        const providerNames = (graph.modelProviders ?? [])
-            .map((provider) => typeof provider.name === 'string' ? provider.name : undefined)
-            .filter((name) => Boolean(name));
-        console.log(`  Detected harness: ${(graph.runtimeAgents ?? []).length} runtime agent(s), ` +
-            `${(graph.artifacts ?? []).length} artifact(s), ${(graph.relationships ?? []).length} relationship(s)`);
-        if (frameworkNames.length > 0)
-            console.log(`  Frameworks: ${frameworkNames.join(', ')}`);
-        if (providerNames.length > 0)
-            console.log(`  Model providers: ${providerNames.join(', ')}`);
-    }
-    catch {
-        console.log('  Detected harness summary is available in .moda/HARNESS.md');
-    }
-}
-function signalsFromGraph(graph) {
-    const names = (items) => (items ?? [])
-        .map((item) => (typeof item.name === 'string' ? item.name : undefined))
-        .filter((name) => Boolean(name));
-    return {
-        runtimeAgents: Array.isArray(graph.runtimeAgents) ? graph.runtimeAgents.length : 0,
-        frameworks: names(graph.agentFrameworks),
-        providers: names(graph.modelProviders),
-    };
-}
-/**
- * Read the gate signals from the SAME graph the auto-sync uploads: the cited
- * report (`.moda/harness-report.json`, consumed by `harness sync --from-report`)
- * is authoritative, so read its `graph` first. Only fall back to the standalone
- * manifest (`.moda/harness.json`) when no report exists, otherwise a stale or
- * missing manifest could let an empty report slip past the gate and overwrite
- * the tenant's harness. Returns undefined when neither is readable.
- */
-export function readHarnessQualitySignals(cwd = process.cwd()) {
-    const reportPath = join(cwd, '.moda', 'harness-report.json');
-    if (existsSync(reportPath)) {
-        try {
-            const report = JSON.parse(readFileSync(reportPath, 'utf8'));
-            if (report.graph && typeof report.graph === 'object') {
-                return signalsFromGraph(report.graph);
-            }
-        }
-        catch {
-            // Fall through to the manifest below.
-        }
-    }
-    const manifestPath = join(cwd, '.moda', 'harness.json');
-    if (!existsSync(manifestPath))
-        return undefined;
-    try {
-        return signalsFromGraph(JSON.parse(readFileSync(manifestPath, 'utf8')));
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * True when discovery found no runtime agents even though the repo carries
- * LLM framework/provider signals — the signature of a failed discovery run,
- * not an agent-free repo.
- */
-export function harnessLooksIncomplete(signals) {
-    return signals.runtimeAgents === 0 &&
-        (signals.frameworks.length > 0 || signals.providers.length > 0);
-}
-// --- Repo-side LLM dependency scan (0-agent gate evidence) -----------------
-//
-// The gate must not read its "repo has LLM signals" evidence solely from the
-// artifact it is gating: a TOTAL discovery failure emits a graph with 0
-// agents AND 0 frameworks/providers, which would sail past a graph-only
-// check and overwrite the tenant's harness with an empty graph. This scan is
-// deterministic and independent of the analyst: it looks for well-known LLM
-// packages in dependency manifests (package.json, requirements.txt,
-// pyproject.toml) via a bounded walk.
-const REPO_SIGNAL_MAX_DEPTH = 3;
-const REPO_SIGNAL_MAX_DIRS = 500;
-const REPO_SIGNAL_SKIPPED_DIRS = new Set([
-    'node_modules', 'dist', 'build', 'out', 'coverage', 'vendor', 'target',
-    'venv', 'env', '__pycache__', 'site-packages',
-]);
-/** Exact npm package name → signal. */
-const JS_LLM_DEPENDENCIES = {
-    openai: { name: 'OpenAI', kind: 'provider' },
-    '@anthropic-ai/sdk': { name: 'Anthropic', kind: 'provider' },
-    '@google/generative-ai': { name: 'Google Gemini', kind: 'provider' },
-    '@google/genai': { name: 'Google Gemini', kind: 'provider' },
-    'cohere-ai': { name: 'Cohere', kind: 'provider' },
-    'groq-sdk': { name: 'Groq', kind: 'provider' },
-    '@mistralai/mistralai': { name: 'Mistral', kind: 'provider' },
-    ollama: { name: 'Ollama', kind: 'provider' },
-    'together-ai': { name: 'Together', kind: 'provider' },
-    '@aws-sdk/client-bedrock-runtime': { name: 'AWS Bedrock', kind: 'provider' },
-    ai: { name: 'Vercel AI SDK', kind: 'framework' },
-    langchain: { name: 'LangChain', kind: 'framework' },
-    llamaindex: { name: 'LlamaIndex', kind: 'framework' },
-    '@anthropic-ai/claude-agent-sdk': { name: 'Claude Agent SDK', kind: 'framework' },
-    '@openai/agents': { name: 'OpenAI Agents', kind: 'framework' },
-    '@mastra/core': { name: 'Mastra', kind: 'framework' },
-};
-/** npm scope/prefix → signal (monorepo-style split packages). */
-const JS_LLM_DEPENDENCY_PREFIXES = [
-    ['@langchain/', { name: 'LangChain', kind: 'framework' }],
-    ['@ai-sdk/', { name: 'Vercel AI SDK', kind: 'framework' }],
-    ['@llamaindex/', { name: 'LlamaIndex', kind: 'framework' }],
-];
-/** Normalized (lowercase, `_`→`-`) Python distribution name → signal. */
-const PY_LLM_DEPENDENCIES = {
-    openai: { name: 'OpenAI', kind: 'provider' },
-    anthropic: { name: 'Anthropic', kind: 'provider' },
-    'google-generativeai': { name: 'Google Gemini', kind: 'provider' },
-    'google-genai': { name: 'Google Gemini', kind: 'provider' },
-    cohere: { name: 'Cohere', kind: 'provider' },
-    groq: { name: 'Groq', kind: 'provider' },
-    mistralai: { name: 'Mistral', kind: 'provider' },
-    ollama: { name: 'Ollama', kind: 'provider' },
-    langgraph: { name: 'LangGraph', kind: 'framework' },
-    litellm: { name: 'LiteLLM', kind: 'framework' },
-    crewai: { name: 'CrewAI', kind: 'framework' },
-    autogen: { name: 'AutoGen', kind: 'framework' },
-    pyautogen: { name: 'AutoGen', kind: 'framework' },
-    ag2: { name: 'AutoGen', kind: 'framework' },
-    'pydantic-ai': { name: 'Pydantic AI', kind: 'framework' },
-    'openai-agents': { name: 'OpenAI Agents', kind: 'framework' },
-    'semantic-kernel': { name: 'Semantic Kernel', kind: 'framework' },
-    dspy: { name: 'DSPy', kind: 'framework' },
-    'haystack-ai': { name: 'Haystack', kind: 'framework' },
-};
-/** Python prefix matches (langchain, langchain-openai, llama-index-core, ...). */
-const PY_LLM_DEPENDENCY_PREFIXES = [
-    ['langchain', { name: 'LangChain', kind: 'framework' }],
-    ['llama-index', { name: 'LlamaIndex', kind: 'framework' }],
-];
-function jsDependencySignal(dep) {
-    const exact = JS_LLM_DEPENDENCIES[dep];
-    if (exact)
-        return exact;
-    for (const [prefix, signal] of JS_LLM_DEPENDENCY_PREFIXES) {
-        if (dep.startsWith(prefix))
-            return signal;
-    }
-    return undefined;
-}
-function pyDependencySignal(dep) {
-    const normalized = dep.toLowerCase().replace(/_/g, '-');
-    const exact = PY_LLM_DEPENDENCIES[normalized];
-    if (exact)
-        return exact;
-    for (const [prefix, signal] of PY_LLM_DEPENDENCY_PREFIXES) {
-        if (normalized === prefix || normalized.startsWith(`${prefix}-`))
-            return signal;
-    }
-    return undefined;
-}
-/** Requirement names from requirements.txt lines / pyproject.toml specifiers. */
-function pythonRequirementNames(text, file) {
-    const names = [];
-    if (file === 'requirements.txt') {
-        for (const line of text.split('\n')) {
-            const match = /^\s*([A-Za-z0-9][A-Za-z0-9._-]*)/.exec(line);
-            if (match)
-                names.push(match[1]);
-        }
-        return names;
-    }
-    // pyproject.toml: dependency specifiers are quoted strings whose leading
-    // token is the distribution name ("openai>=1.0", "langchain-openai", ...).
-    for (const match of text.matchAll(/["']([A-Za-z0-9][A-Za-z0-9._-]*)[^"']*["']/g)) {
-        names.push(match[1]);
-    }
-    return names;
-}
-/**
- * Deterministic repo-side LLM signals: well-known LLM package names found in
- * dependency manifests. Independent of the discovery output, so a fully
- * failed discovery (empty graph) cannot bypass the 0-agent gate.
- */
-export function detectRepoLlmSignals(cwd = process.cwd()) {
-    const frameworks = new Set();
-    const providers = new Set();
-    const record = (signal) => {
-        if (!signal)
-            return;
-        (signal.kind === 'framework' ? frameworks : providers).add(signal.name);
-    };
-    const scanDir = (dir) => {
-        try {
-            const pkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'));
-            for (const dep of [
-                ...Object.keys(pkg.dependencies ?? {}),
-                ...Object.keys(pkg.devDependencies ?? {}),
-                ...Object.keys(pkg.peerDependencies ?? {}),
-            ]) {
-                record(jsDependencySignal(dep));
-            }
-        }
-        catch {
-            // No/invalid package.json here.
-        }
-        for (const file of ['requirements.txt', 'pyproject.toml']) {
-            try {
-                const text = readFileSync(join(dir, file), 'utf8');
-                for (const name of pythonRequirementNames(text, file)) {
-                    record(pyDependencySignal(name));
-                }
-            }
-            catch {
-                // No such manifest here.
-            }
-        }
-    };
-    let visited = 0;
-    const walk = (dir, depth) => {
-        if (depth > REPO_SIGNAL_MAX_DEPTH || visited >= REPO_SIGNAL_MAX_DIRS)
-            return;
-        visited += 1;
-        scanDir(dir);
-        let entries;
-        try {
-            entries = readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            if (!entry.isDirectory() || entry.name.startsWith('.'))
-                continue;
-            if (REPO_SIGNAL_SKIPPED_DIRS.has(entry.name))
-                continue;
-            walk(join(dir, entry.name), depth + 1);
-        }
-    };
-    walk(cwd, 0);
-    return { frameworks: [...frameworks].sort(), providers: [...providers].sort() };
-}
-/** Agent/artifact counts for the completion screen's harness payoff line. */
-function readHarnessGraphCounts(cwd = process.cwd()) {
-    const manifestPath = join(cwd, '.moda', 'harness.json');
-    if (!existsSync(manifestPath))
-        return {};
-    try {
-        const graph = JSON.parse(readFileSync(manifestPath, 'utf8'));
-        return {
-            agents: Array.isArray(graph.runtimeAgents) ? graph.runtimeAgents.length : 0,
-            artifacts: Array.isArray(graph.artifacts) ? graph.artifacts.length : 0,
-        };
-    }
-    catch {
-        return {};
-    }
-}
-function commandFlags(flags) {
-    return Object.fromEntries(Object.entries(flags)
-        .filter(([, value]) => value !== undefined && value !== false)
-        .map(([key, value]) => [key, value === true ? 'true' : String(value)]));
-}
-function stringFlag(value) {
-    return typeof value === 'string' && value.trim().length > 0 ? value : undefined;
-}
-export function resumeFlagsForInit(flags) {
-    const passthrough = [
-        'profile',
-        'tenant-id',
-        'offline',
-        'analyst',
-        'sdk-integrate',
-        'ci-cd',
-        'autosync',
-        'harness-rescan',
-        'harness-rescan-paths',
-        'no-sdk-integrate',
-        'no-ci-cd',
-        'no-autosync',
-        'no-harness-rescan',
-        'yes',
-        'agent',
-        'json',
-        'stream',
-    ];
-    const out = [];
-    for (const key of passthrough) {
-        const value = flagValue(flags, key, key.replace(/-/g, '_'));
-        if (value === undefined || value === false || value === 'false')
-            continue;
-        const flag = `--${key}`;
-        if (value === true || value === 'true')
-            out.push(flag);
-        else
-            out.push(flag, String(value));
-    }
-    // The rescan choice is derived as `flag ?? (paths ? true : ...)`, so a bare
-    // `--harness-rescan-paths` re-implies opt-in. If the original run explicitly
-    // disabled rescan (via `--harness-rescan=false`, whose false value the loop
-    // above drops), carry the negative through so a resume can't silently write
-    // the workflow the user declined.
-    if (resolveHarnessRescanFlag(flags) === false && !out.includes('--no-harness-rescan')) {
-        out.push('--no-harness-rescan');
-    }
-    return out;
-}
-/**
- * Explicit CI/CD decision from flags, or undefined when the Plan beat decides
- * (interactive default off; --yes/--json/--agent default off).
- */
-function resolveCiCdFlag(flags) {
-    const explicit = parseOptionalBoolean(flagValue(flags, 'ci-cd', 'ci_cd', 'ci'));
-    if (explicit !== undefined)
-        return explicit;
-    if (isTruthyFlag(flagValue(flags, 'no-ci-cd', 'no_ci_cd')))
-        return false;
-    return undefined;
-}
-/** Explicit autosync decision from flags, or undefined when the Plan beat decides. */
-function resolveAutosyncFlag(flags) {
-    const explicit = parseOptionalBoolean(flagValue(flags, 'autosync', 'auto-sync', 'auto_sync'));
-    if (explicit !== undefined)
-        return explicit;
-    if (isTruthyFlag(flagValue(flags, 'no-autosync', 'no_autosync', 'no-auto-sync', 'no_auto_sync')))
-        return false;
-    return undefined;
-}
-/** Explicit harness-rescan decision from flags, or undefined when the Plan beat decides. */
-function resolveHarnessRescanFlag(flags) {
-    const explicit = parseOptionalBoolean(flagValue(flags, 'harness-rescan', 'harness_rescan'));
-    if (explicit !== undefined)
-        return explicit;
-    if (isTruthyFlag(flagValue(flags, 'no-harness-rescan', 'no_harness_rescan')))
-        return false;
-    return undefined;
-}
-/**
- * Comma-separated path globs for the rescan workflow's `on.push.paths` scope.
- * `undefined` when the flag is absent (or carries no usable globs), so a bare
- * `--harness-rescan` still writes an unscoped rescan-on-every-push workflow.
- */
-function parseHarnessRescanPaths(value) {
-    if (typeof value !== 'string')
-        return undefined;
-    const globs = value
-        .split(',')
-        .map((glob) => glob.trim())
-        .filter((glob) => glob.length > 0 && glob !== 'true');
-    return globs.length > 0 ? globs : undefined;
-}
-/**
- * Explicit SDK-integration decision from flags, or undefined when the Plan
- * beat decides (interactive default: on when a coding-agent CLI is installed;
- * --yes/--json/--agent default off because the agent edits source and installs
- * packages, which must never happen unattended without an explicit opt-in).
- */
-function resolveSdkIntegrateFlag(flags) {
-    const explicit = parseOptionalBoolean(flagValue(flags, 'sdk-integrate', 'sdk_integrate', 'sdk-guide', 'sdk_guide', 'sdk'));
-    if (explicit !== undefined)
-        return explicit;
-    if (isTruthyFlag(flagValue(flags, 'no-sdk-integrate', 'no_sdk_integrate', 'no-sdk-guide', 'no_sdk_guide', 'no-sdk', 'no_sdk'))) {
-        return false;
-    }
-    return undefined;
-}
-function parseOptionalBoolean(value) {
-    if (value === undefined)
-        return undefined;
-    // The CLI parser normalizes numeric-looking flag values to numbers, so
-    // `--remote=1` arrives as number 1 and `--remote=0` as number 0 (not the
-    // string spellings); accept both alongside the string/boolean forms.
-    if (value === true || value === 1 || value === 'true' || value === '1' || value === 'yes')
-        return true;
-    if (value === false || value === 0 || value === 'false' || value === '0' || value === 'no')
-        return false;
-    return undefined;
-}
-function isTruthyFlag(value) {
-    // The CLI normalizes numeric-looking flag values to numbers (`--remote=1` →
-    // number 1), so accept the numeric `1` alongside the string spellings.
-    return value === true || value === 1 || value === 'true' || value === '1' || value === 'yes';
-}
-/**
- * Onboarding runs harness discovery SERVER-SIDE by default so the customer
- * needs no local coding agent. Opt out with `--local`, `--no-remote`,
- * `--remote=false`, or an explicit deterministic local analyst
- * (`--analyst=local-scan|local|scripted|moda`).
- */
-export function resolveHarnessRemote(flags) {
-    if (isTruthyFlag(flagValue(flags, 'local')))
-        return false;
-    if (isTruthyFlag(flagValue(flags, 'no-remote', 'no_remote')))
-        return false;
-    const remote = parseOptionalBoolean(flagValue(flags, 'remote'));
-    if (remote !== undefined)
-        return remote;
-    // Scenarios and users that pin `--analyst=local-scan` mean "run the local
-    // deterministic scanner", not "upload to hosted analyze and poll". Treat that
-    // as an implicit local opt-out so moda-test live/onboarding suites and
-    // developer workflows do not hang waiting on remote analyze.
-    if (isDeterministicLocalAnalyst(stringFlag(flagValue(flags, 'analyst')))) {
-        return false;
-    }
-    return true;
-}
-/**
- * True when the user pinned the remote/local decision (flags or a
- * deterministic analyst), so the Plan checkbox must not offer to re-toggle it.
- */
-function hasExplicitRemoteChoice(flags) {
-    if (isTruthyFlag(flagValue(flags, 'local')))
-        return true;
-    if (isTruthyFlag(flagValue(flags, 'no-remote', 'no_remote')))
-        return true;
-    if (parseOptionalBoolean(flagValue(flags, 'remote')) !== undefined)
-        return true;
-    return isDeterministicLocalAnalyst(stringFlag(flagValue(flags, 'analyst')));
-}
-function flagValue(flags, ...keys) {
-    for (const key of keys) {
-        if (flags[key] !== undefined)
-            return flags[key];
-    }
-    return undefined;
-}
-//# sourceMappingURL=index.js.map