vana-cli 0.15.0

package/dist/cli/index.js

@@ -0,0 +1,4703 @@
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { spawn, execSync } from "node:child_process";
+import os from "node:os";
+import { confirm, input, password } from "@inquirer/prompts";
+import { searchSelect } from "./search-select.js";
+import { Command, CommanderError } from "commander";
+// Vana-branded theme for inquirer prompts — matches brand palette
+const VANA_BLUE = "\x1b[38;2;65;65;252m";
+const VANA_GREEN = "\x1b[38;2;0;213;11m";
+const VANA_MUTED = "\x1b[38;2;112;112;112m";
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const BOLD_RESET = "\x1b[22m";
+const vanaPromptTheme = {
+    theme: {
+        prefix: { idle: `${VANA_BLUE}?${RESET}`, done: `${VANA_GREEN}✓${RESET}` },
+        style: {
+            answer: (text) => `${BOLD}${text}${BOLD_RESET}`,
+            message: (text, status) => status === "done" ? `${VANA_MUTED}${text}${RESET}` : text,
+            highlight: (text) => `${VANA_BLUE}${text}${RESET}`,
+            help: (text) => `${VANA_MUTED}${text}${RESET}`,
+            error: (text) => `\x1b[38;2;231;0;11m${text}${RESET}`,
+        },
+    },
+};
+import { createConnectRenderer, createHumanRenderer, createLoginRenderer, formatDisplayPath, formatRelativeTime, } from "./render/index.js";
+import { CliOutcomeStatus, migrateLegacyDataHome, getBrowserProfilesDir, getConnectorCacheDir, getLogsDir, getSessionsDir, getSourceResultPath, readCliState, readCliConfig, updateCliConfig, updateSourceState, } from "../core/index.js";
+import { fetchConnectorToCache, listAvailableSources, readCachedConnectorMetadata, } from "../connectors/registry.js";
+import { detectPersonalServerTarget, ingestResult, resolvePersonalServerAuthConfig, } from "../personal-server/index.js";
+import { findDataConnectorsDir, ManagedPlaywrightRuntime, } from "../runtime/index.js";
+import { listAvailableSkills, installSkill, readInstalledSkills, } from "../skills/index.js";
+import { queryStatus, querySources, queryDataList, queryDataShow, queryDoctor, } from "./queries.js";
+import { checkForUpdate, readUpdateCheck, isNewerVersion, } from "./update-check.js";
+import { loadCredentials, saveCredentials, clearCredentials, isExpired, formatAddress, formatExpiresIn, getAuthTarget, resolvePersonalServerUrl, runDeviceCodeFlow, runSelfHostedLoginFlow, } from "./auth.js";
+import { createCliTelemetrySession, flushTelemetryOutbox, getActiveTelemetrySession, getTelemetryStatus, setActiveTelemetrySession, setTelemetryEnabled, trackActiveTelemetryEvent, } from "./telemetry.js";
+function cleanDescription(desc) {
+    return desc
+        .replace(/ using Playwright browser automation\.?/i, ".")
+        .replace(/^Exports\b\s*(your\s+)?/i, "Your ");
+}
+const require = createRequire(import.meta.url);
+export async function runCli(argv = process.argv) {
+    // Migrate ~/.dataconnect → ~/.vana, symlink old path for DataConnect compat
+    if (migrateLegacyDataHome()) {
+        process.stderr.write("Moved your data to ~/.vana.\n\n");
+    }
+    const normalizedArgv = normalizeArgv(argv);
+    if (normalizedArgv.length <= 2) {
+        normalizedArgv.push("--help");
+    }
+    const parsedOptions = extractGlobalOptions(normalizedArgv);
+    const cliVersion = getCliVersion();
+    const installMethod = getCliInstallMethod();
+    const telemetryBaseContext = {
+        cliVersion,
+        channel: getCliChannel(cliVersion),
+        installMethod,
+        options: parsedOptions,
+    };
+    // Non-blocking update check — compute suppression flags early
+    const shouldNotify = !parsedOptions.json &&
+        process.stdout.isTTY &&
+        installMethod !== "development" &&
+        !process.env.VANA_NO_UPDATE_NOTIFIER &&
+        !process.env.CI &&
+        !process.env.AGENT &&
+        !process.env.VANA_DETACHED;
+    // Fire update check concurrently — no await, runs in the background.
+    // If it finishes before the command completes, the cache is written and
+    // the SAME run can read it for the notification below.
+    const updateCheckPromise = shouldNotify
+        ? checkForUpdate(cliVersion, installMethod).catch(() => { })
+        : undefined;
+    const program = new Command();
+    program
+        .name("vana")
+        .description("Connect sources, collect data, and inspect it locally.")
+        .version(cliVersion, "-v, --version", "Print CLI version")
+        .showSuggestionAfterError(true)
+        .addHelpText("after", `
+Quick start:
+  vana login             Log in to your Vana account
+  vana connect           Connect a source and collect data
+  vana sources           Browse available sources
+  vana status            Check system health
+
+Data:
+  vana data list         List collected datasets
+  vana data show <src>   Inspect a dataset
+
+Server:
+  vana server            Personal Server status and management
+
+Agent:
+  vana mcp               Start MCP server (for Claude Code, Cursor, etc.)
+  vana skills list         List available agent skills
+  vana skills install      Install a skill for your agent
+
+Background:
+  vana connect <src> --detach   Connect in the background
+  vana schedule add             Schedule daily collection
+  vana schedule list            Show scheduled tasks
+
+More:
+  vana doctor            Detailed diagnostics
+  vana logs [source]     View run logs
+  vana setup             Install or repair runtime
+`);
+    program.exitOverride();
+    program
+        .command("version")
+        .description("Print CLI version")
+        .option("--json", "Output machine-readable JSON")
+        .action(async () => {
+        process.exitCode = await runCommandWithTelemetry({ ...telemetryBaseContext, command: "version" }, async () => {
+            if (parsedOptions.json) {
+                process.stdout.write(`${JSON.stringify({
+                    cliVersion,
+                    channel: getCliChannel(cliVersion),
+                    installMethod: getCliInstallMethod(),
+                })}\n`);
+                return 0;
+            }
+            process.stdout.write(`${cliVersion} (${getCliChannel(cliVersion)}, ${formatInstallMethodLabel(getCliInstallMethod()).toLowerCase()})\n`);
+            return 0;
+        });
+    });
+    const connectCommand = program
+        .command("connect [source]")
+        .description("Connect a source and collect data")
+        .option("--json", "Output machine-readable JSON")
+        .option("--no-input", "Fail instead of prompting for input")
+        .option("--ipc", "Use file-based IPC for credential prompts (for agents)")
+        .option("--yes", "Approve safe setup prompts automatically")
+        .option("--quiet", "Reduce non-essential output")
+        .option("--detach", "Run in the background")
+        .action(async (source) => {
+        process.exitCode = await runCommandWithTelemetry({ ...telemetryBaseContext, command: "connect", source }, async () => {
+            if (parsedOptions.detach && source) {
+                return runDetached("connect", source, parsedOptions);
+            }
+            return source
+                ? runConnect(source, parsedOptions)
+                : runConnectEntry(parsedOptions);
+        });
+    });
+    connectCommand.addHelpText("after", `
+Examples:
+  vana connect
+  vana connect github
+  vana connect github --json --no-input
+  vana connect github --json --ipc
+`);
+    const sourcesCommand = program
+        .command("sources [source]")
+        .description("List supported sources, or show detail for one source")
+        .option("--json", "Output machine-readable JSON")
+        .action(async (source) => {
+        process.exitCode = await runCommandWithTelemetry({ ...telemetryBaseContext, command: "sources", source }, async () => source
+            ? runSourceDetail(source, parsedOptions)
+            : runList(parsedOptions));
+    });
+    sourcesCommand.addHelpText("after", `
+Examples:
+  vana sources
+  vana sources github
+  vana sources --json | jq '.sources'
+`);
+    const collectCommand = program
+        .command("collect [source]")
+        .description("Re-collect data from a previously connected source")
+        .option("--json", "Output machine-readable JSON")
+        .option("--no-input", "Fail instead of prompting for input")
+        .option("--ipc", "Use file-based IPC for credential prompts (for agents)")
+        .option("--yes", "Approve safe setup prompts automatically")
+        .option("--quiet", "Reduce non-essential output")
+        .option("--detach", "Run in the background")
+        .option("--all", "Collect from all connected sources")
+        .action(async (source) => {
+        process.exitCode = await runCommandWithTelemetry({ ...telemetryBaseContext, command: "collect", source }, async () => {
+            if (parsedOptions.detach && source) {
+                return runDetached("collect", source, parsedOptions);
+            }
+            return source
+                ? runCollect(source, parsedOptions)
+                : runCollectAll(parsedOptions);
+        });
+    });
+    collectCommand.addHelpText("after", `
+Examples:
+  vana collect github
+  vana collect
+  vana collect --json
+`);
+    const statusCommand = program
+        .command("status")
+        .description("Show runtime and Personal Server status")
+        .option("--json", "Output machine-readable JSON")
+        .action(async () => {
+        process.exitCode = await runCommandWithTelemetry({ ...telemetryBaseContext, command: "status" }, async () => runStatus(parsedOptions));
+    });
+    statusCommand.addHelpText("after", `
+Examples:
+  vana status
+  vana status --json | jq
+`);
+    const doctorCommand = program
+        .command("doctor")
+        .description("Inspect local CLI, runtime, and install health")
+        .option("--json", "Output machine-readable JSON")
+        .action(async () => {
+        process.exitCode = await runCommandWithTelemetry({ ...telemetryBaseContext, command: "doctor" }, async () => runDoctor(parsedOptions));
+    });
+    doctorCommand.addHelpText("after", `
+Examples:
+  vana doctor
+  vana doctor --json | jq
+`);
+    const setupCommand = program
+        .command("setup")
+        .description("Install or repair the local runtime")
+        .option("--json", "Output machine-readable JSON")
+        .option("--yes", "Approve safe setup prompts automatically")
+        .action(async () => {
+        process.exitCode = await runCommandWithTelemetry({ ...telemetryBaseContext, command: "setup" }, async () => runSetup(parsedOptions));
+    });
+    setupCommand.addHelpText("after", `
+Examples:
+  vana setup
+  vana setup --yes
+`);
+    const data = program
+        .command("data")
+        .description("Inspect collected datasets, paths, and summaries");
+    data.addHelpText("after", `
+Examples:
+  vana data list
+  vana data show github
+  vana data path github --json
+`);
+    data.action(() => {
+        data.outputHelp();
+        process.exitCode = 0;
+    });
+    const dataListCommand = data
+        .command("list")
+        .description("List locally available collected datasets")
+        .option("--json", "Output machine-readable JSON")
+        .action(async () => {
+        process.exitCode = await runCommandWithTelemetry({ ...telemetryBaseContext, command: "data", subcommand: "list" }, async () => runDataList(parsedOptions));
+    });
+    dataListCommand.addHelpText("after", `
+Examples:
+  vana data list
+  vana data list --json | jq '.datasets'
+`);
+    const dataShowCommand = data
+        .command("show <source>")
+        .description("Show a collected dataset")
+        .option("--json", "Output machine-readable JSON")
+        .action(async (source) => {
+        process.exitCode = await runCommandWithTelemetry({
+            ...telemetryBaseContext,
+            command: "data",
+            subcommand: "show",
+            source,
+        }, async () => runDataShow(source, parsedOptions));
+    });
+    dataShowCommand.addHelpText("after", `
+Examples:
+  vana data show github
+  vana data show github --json | jq '.summary'
+`);
+    const dataPathCommand = data
+        .command("path <source>")
+        .description("Print the local path for a collected dataset")
+        .option("--json", "Output machine-readable JSON")
+        .action(async (source) => {
+        process.exitCode = await runCommandWithTelemetry({
+            ...telemetryBaseContext,
+            command: "data",
+            subcommand: "path",
+            source,
+        }, async () => runDataPath(source, parsedOptions));
+    });
+    dataPathCommand.addHelpText("after", `
+Examples:
+  vana data path github
+  vana data path github --json | jq -r '.path'
+`);
+    const logsCommand = program
+        .command("logs [source]")
+        .description("Inspect stored connector run logs")
+        .option("--json", "Output machine-readable JSON")
+        .action(async (source) => {
+        process.exitCode = await runCommandWithTelemetry({ ...telemetryBaseContext, command: "logs", source }, async () => runLogs(source, parsedOptions));
+    });
+    logsCommand.addHelpText("after", `
+Examples:
+  vana logs
+  vana logs github
+  vana logs github --json | jq
+`);
+    const server = program
+        .command("server")
+        .description("Manage Personal Server connection")
+        .option("--json", "Output machine-readable JSON");
+    server.addHelpText("after", `
+Examples:
+  vana server
+  vana server set-url http://localhost:8080
+  vana server set-url https://ps-abc123.server.vana.org
+  vana server clear-url
+`);
+    server.action(async () => {
+        process.exitCode = await runCommandWithTelemetry({ ...telemetryBaseContext, command: "server", subcommand: "status" }, async () => runServerStatus(parsedOptions));
+    });
+    server
+        .command("status")
+        .description("Show Personal Server status")
+        .option("--json", "Output machine-readable JSON")
+        .action(async () => {
+        process.exitCode = await runCommandWithTelemetry({ ...telemetryBaseContext, command: "server", subcommand: "status" }, async () => runServerStatus(parsedOptions));
+    });
+    server
+        .command("set-url <url>")
+        .description("Save a Personal Server URL")
+        .option("--json", "Output machine-readable JSON")
+        .action(async (url) => {
+        process.exitCode = await runCommandWithTelemetry({ ...telemetryBaseContext, command: "server", subcommand: "set-url" }, async () => runServerSetUrl(url, parsedOptions));
+    });
+    server
+        .command("clear-url")
+        .description("Remove the saved Personal Server URL")
+        .option("--json", "Output machine-readable JSON")
+        .action(async () => {
+        process.exitCode = await runCommandWithTelemetry({ ...telemetryBaseContext, command: "server", subcommand: "clear-url" }, async () => runServerClearUrl(parsedOptions));
+    });
+    server
+        .command("sync")
+        .description("Sync all local-only datasets to your Personal Server")
+        .option("--json", "Output machine-readable JSON")
+        .action(async () => {
+        process.exitCode = await runCommandWithTelemetry({ ...telemetryBaseContext, command: "server", subcommand: "sync" }, async () => runServerSync(parsedOptions));
+    });
+    server
+        .command("data [scope]")
+        .description("List scopes stored in your Personal Server")
+        .option("--json", "Output machine-readable JSON")
+        .action(async (scope) => {
+        process.exitCode = await runCommandWithTelemetry({ ...telemetryBaseContext, command: "server", subcommand: "data" }, async () => runServerData(scope, parsedOptions));
+    });
+    program
+        .command("login")
+        .description("Log in to your Vana account or a self-hosted Personal Server")
+        .option("-s, --server <url>", "Self-hosted Personal Server URL")
+        .option("--client-id <id>", "OAuth public client ID for Vana Account login")
+        .action(async (loginOptions) => {
+        process.exitCode = await runCommandWithTelemetry({ ...telemetryBaseContext, command: "login" }, async () => runLogin(parsedOptions, loginOptions.server, loginOptions.clientId));
+    });
+    program
+        .command("logout")
+        .description("Log out and remove saved credentials")
+        .action(async () => {
+        process.exitCode = await runCommandWithTelemetry({ ...telemetryBaseContext, command: "logout" }, async () => runLogout(parsedOptions));
+    });
+    const telemetry = program
+        .command("telemetry")
+        .description("Inspect and manage CLI telemetry");
+    telemetry.action(async () => {
+        process.exitCode = await runTelemetryStatus(parsedOptions);
+    });
+    telemetry
+        .command("status")
+        .description("Show telemetry state")
+        .option("--json", "Output machine-readable JSON")
+        .action(async () => {
+        process.exitCode = await runTelemetryStatus(parsedOptions);
+    });
+    telemetry
+        .command("enable")
+        .description("Enable telemetry")
+        .action(async () => {
+        process.exitCode = await runTelemetryEnable(parsedOptions);
+    });
+    telemetry
+        .command("disable")
+        .description("Disable telemetry")
+        .action(async () => {
+        process.exitCode = await runTelemetryDisable(parsedOptions);
+    });
+    program
+        .command("mcp")
+        .description("Start MCP server for agent integration")
+        .action(async () => {
+        process.exitCode = await runLongRunningCommandWithTelemetry({ ...telemetryBaseContext, command: "mcp" }, async () => {
+            const { startMcpServer } = await import("./mcp-server.js");
+            await startMcpServer();
+        });
+    });
+    const skill = program
+        .command("skills")
+        .description("Manage agent skills")
+        .option("--json", "Output as JSON");
+    skill.addHelpText("after", `
+Examples:
+  vana skills list
+  vana skills install connect-data
+  vana skills show connect-data
+`);
+    skill.action(async () => {
+        process.exitCode = await runCommandWithTelemetry({ ...telemetryBaseContext, command: "skills" }, async () => runSkillsGuidedPicker(parsedOptions));
+    });
+    skill
+        .command("list")
+        .description("List available agent skills")
+        .option("--json", "Output as JSON")
+        .action(async () => {
+        process.exitCode = await runCommandWithTelemetry({ ...telemetryBaseContext, command: "skills", subcommand: "list" }, async () => runSkillList(parsedOptions));
+    });
+    skill
+        .command("install <name>")
+        .description("Install a skill for your agent")
+        .action(async (name) => {
+        process.exitCode = await runCommandWithTelemetry({ ...telemetryBaseContext, command: "skills", subcommand: "install" }, async () => runSkillInstall(name, parsedOptions));
+    });
+    skill
+        .command("show <name>")
+        .description("Show skill details")
+        .action(async (name) => {
+        process.exitCode = await runCommandWithTelemetry({ ...telemetryBaseContext, command: "skills", subcommand: "show" }, async () => runSkillShow(name, parsedOptions));
+    });
+    // --- Schedule commands ---
+    const schedule = program
+        .command("schedule")
+        .description("Manage scheduled data collection");
+    schedule.addHelpText("after", `
+Examples:
+  vana schedule add
+  vana schedule add --every 12h
+  vana schedule list
+  vana schedule remove
+`);
+    schedule.action(() => {
+        schedule.outputHelp();
+        process.exitCode = 0;
+    });
+    schedule
+        .command("add")
+        .description("Add a scheduled collection")
+        .option("--every <interval>", "Collection interval (e.g. 24h, 12h, 1h)", "24h")
+        .action(async (opts) => {
+        process.exitCode = await runCommandWithTelemetry({ ...telemetryBaseContext, command: "schedule", subcommand: "add" }, async () => runScheduleAdd(opts.every, parsedOptions));
+    });
+    schedule
+        .command("list")
+        .description("Show scheduled tasks")
+        .option("--json", "Output machine-readable JSON")
+        .action(async () => {
+        process.exitCode = await runCommandWithTelemetry({ ...telemetryBaseContext, command: "schedule", subcommand: "list" }, async () => runScheduleList(parsedOptions));
+    });
+    schedule
+        .command("remove")
+        .description("Remove the scheduled collection")
+        .action(async () => {
+        process.exitCode = await runCommandWithTelemetry({ ...telemetryBaseContext, command: "schedule", subcommand: "remove" }, async () => runScheduleRemove(parsedOptions));
+    });
+    try {
+        await program.parseAsync(normalizedArgv);
+    }
+    catch (error) {
+        if (error instanceof CommanderError) {
+            if (error.code === "commander.help" ||
+                error.code === "commander.helpDisplayed" ||
+                error.code === "commander.version") {
+                process.exitCode = error.exitCode;
+                return Number(process.exitCode ?? 0);
+            }
+            // Commander already printed to stderr; just set exit code.
+            process.exitCode = error.exitCode;
+            return Number(process.exitCode ?? 1);
+        }
+        throw error;
+    }
+    // Show update notification if a newer version is available.
+    // The concurrent check may have populated the cache during this run.
+    if (shouldNotify) {
+        try {
+            await Promise.race([
+                updateCheckPromise,
+                new Promise((resolve) => setTimeout(resolve, 2000)),
+            ]);
+            const cache = await readUpdateCheck();
+            if (cache && isNewerVersion(cliVersion, cache.latestVersion)) {
+                const { upgrade } = getLifecycleCommands(installMethod, getCliChannel(cliVersion));
+                process.stderr.write(`\nUpdate available: ${cliVersion} → ${cache.latestVersion}\nRun: ${upgrade}\n`);
+            }
+        }
+        catch {
+            // Never block exit for update notification failures
+        }
+    }
+    return Number(process.exitCode ?? 0);
+}
+function classifyCommandFailure(error) {
+    if (error instanceof Error) {
+        const value = error.message.toLowerCase();
+        if (value.includes("needs_input") ||
+            value.includes("needs input") ||
+            value.includes("input required") ||
+            value.includes("manual step"))
+            return "needs_input";
+        if (value.includes("prompt_cancelled") || value.includes("cancelled"))
+            return "prompt_cancelled";
+        if (value.includes("personal_server_unavailable") ||
+            value.includes("personal server unavailable"))
+            return "personal_server_unavailable";
+        if (value.includes("auth expired"))
+            return "auth_expired";
+        if (value.includes("auth"))
+            return "auth_failed";
+        if (value.includes("setup"))
+            return "setup_required";
+        if (value.includes("timeout") || value.includes("timed out"))
+            return "timeout";
+        if (value.includes("network"))
+            return "network_error";
+        if (value.includes("runtime"))
+            return "runtime_error";
+        if (value.includes("connector"))
+            return "connector_unavailable";
+        if (value.includes("ingest"))
+            return "ingest_failed";
+    }
+    return "unknown";
+}
+async function runCommandWithTelemetry(context, action) {
+    const session = await createCliTelemetrySession({
+        ...context,
+        options: {
+            json: Boolean(context.options.json),
+            noInput: Boolean(context.options.noInput),
+            quiet: Boolean(context.options.quiet),
+            detach: Boolean(context.options.detach),
+            ipc: Boolean(context.options.ipc),
+        },
+        localOnly: context.localOnly,
+    });
+    setActiveTelemetrySession(session);
+    await flushTelemetryOutbox();
+    try {
+        const exitCode = await action();
+        session.markCommandResult({ exitCode });
+        return exitCode;
+    }
+    catch (error) {
+        session.markCommandResult({
+            exitCode: 1,
+            errorClass: classifyCommandFailure(error),
+        });
+        throw error;
+    }
+    finally {
+        await session.persist();
+        await session.flush();
+        setActiveTelemetrySession(null);
+    }
+}
+async function runLongRunningCommandWithTelemetry(context, action) {
+    const session = await createCliTelemetrySession({
+        ...context,
+        options: {
+            json: Boolean(context.options.json),
+            noInput: Boolean(context.options.noInput),
+            quiet: Boolean(context.options.quiet),
+            detach: Boolean(context.options.detach),
+            ipc: Boolean(context.options.ipc),
+        },
+    });
+    setActiveTelemetrySession(session);
+    await flushTelemetryOutbox();
+    session.trackCustomEvent("mcp_started");
+    session.markCommandResult({ exitCode: 0, outcome: "started" });
+    await session.persist();
+    await session.flush();
+    try {
+        await action();
+        return 0;
+    }
+    finally {
+        setActiveTelemetrySession(null);
+    }
+}
+async function runTelemetryStatus(options) {
+    const status = await getTelemetryStatus();
+    const endpointHost = (() => {
+        try {
+            return new URL(status.endpoint).host;
+        }
+        catch {
+            return status.endpoint;
+        }
+    })();
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify(status)}\n`);
+        return 0;
+    }
+    const emit = createEmitter(options);
+    emit.title("Telemetry");
+    emit.blank();
+    emit.keyValue("Enabled", status.enabled ? "yes" : "no");
+    emit.keyValue("Mode", status.mode);
+    emit.keyValue("Reason", status.reason.replaceAll("_", " "));
+    emit.keyValue("Endpoint", endpointHost);
+    emit.keyValue("Queued", String(status.queuedBatches));
+    emit.detail("Collected data stays local. Remote telemetry only includes small operational events.");
+    if (status.enabled) {
+        emit.detail(`Disable with: ${emit.code("vana telemetry disable")}`);
+    }
+    else {
+        emit.detail(`Enable with: ${emit.code("vana telemetry enable")}`);
+    }
+    if (process.env.VANA_TELEMETRY_DEBUG === "1") {
+        emit.detail(`Debug mode is active via ${emit.code("VANA_TELEMETRY_DEBUG=1")}. Events print to stderr and are not uploaded.`);
+    }
+    if (process.env.VANA_TELEMETRY_DISABLED === "1") {
+        emit.detail(`Telemetry is currently overridden by ${emit.code("VANA_TELEMETRY_DISABLED=1")}.`);
+    }
+    return 0;
+}
+async function runTelemetryEnable(options) {
+    await setTelemetryEnabled(true);
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({ enabled: true })}\n`);
+        return 0;
+    }
+    const emit = createEmitter(options);
+    emit.success("Telemetry enabled.");
+    if (process.env.VANA_TELEMETRY_DISABLED === "1") {
+        emit.detail(`The current shell still disables uploads via ${emit.code("VANA_TELEMETRY_DISABLED=1")}.`);
+    }
+    return 0;
+}
+async function runTelemetryDisable(options) {
+    await setTelemetryEnabled(false);
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({ enabled: false })}\n`);
+        return 0;
+    }
+    const emit = createEmitter(options);
+    emit.success("Telemetry disabled.");
+    return 0;
+}
+async function runConnect(rawSource, options) {
+    const source = rawSource.toLowerCase();
+    const runtime = new ManagedPlaywrightRuntime();
+    const emit = createEmitter(options);
+    const renderer = !options.json && !options.quiet ? createConnectRenderer() : null;
+    const registrySources = await loadRegistrySources();
+    const sourceLabels = createSourceLabelMap(registrySources);
+    const displayName = displaySource(source, sourceLabels);
+    let setupLogPath;
+    let fetchLogPath;
+    let runLogPath;
+    let pendingExitCode = null;
+    try {
+        // Title
+        renderer?.title(displayName);
+        const target = await detectPersonalServerTarget();
+        // --- Phase 1: Runtime check (silent if installed) ---
+        if (runtime.state !== "installed") {
+            if (options.noInput) {
+                emit.event({
+                    type: "outcome",
+                    status: CliOutcomeStatus.SETUP_REQUIRED,
+                    source,
+                });
+                renderer?.fail(`${displayName} needs a local browser runtime. Run without --no-input to install.`);
+                return 1;
+            }
+            if (!options.yes) {
+                renderer?.cleanup();
+                process.stderr.write("\n");
+                process.stderr.write("Vana Connect needs a local browser runtime.\n\n");
+                process.stderr.write("This will install:\n");
+                process.stderr.write("  \u2022 Connector runner\n");
+                process.stderr.write("  \u2022 Chromium browser engine\n");
+                process.stderr.write("  \u2022 Local files under ~/.vana/\n\n");
+                process.stderr.write("Your credentials stay on this machine.\n\n");
+                const shouldContinue = await confirm({
+                    message: "Continue?",
+                    default: true,
+                    ...vanaPromptTheme,
+                });
+                if (!shouldContinue) {
+                    renderer?.fail("Cancelled.");
+                    emit.event({
+                        type: "outcome",
+                        status: CliOutcomeStatus.SETUP_REQUIRED,
+                        source,
+                        reason: "setup_declined",
+                    });
+                    return 1;
+                }
+                process.stderr.write("\n");
+            }
+            trackActiveTelemetryEvent("runtime_install_started", { source });
+            let installResult;
+            try {
+                installResult = await runtime.ensureInstalled(Boolean(options.yes));
+            }
+            catch (error) {
+                trackActiveTelemetryEvent("runtime_install_failed", {
+                    source,
+                    errorClass: classifyCommandFailure(error),
+                });
+                throw error;
+            }
+            setupLogPath = installResult.logPath;
+            emit.event({
+                type: "setup-complete",
+                runtime: installResult.runtime,
+                logPath: installResult.logPath,
+            });
+            renderer?.scopeDone("Runtime ready");
+        }
+        else {
+            emit.event({
+                type: "setup-check",
+                runtime: runtime.state,
+            });
+        }
+        // --- Phase 2: Connector fetch (silent if cached/fast) ---
+        const preState = await readCliState();
+        const currentVersion = preState.sources[source]?.connectorVersion;
+        let fetched;
+        try {
+            fetched = await runtime.fetchConnector(source, currentVersion);
+        }
+        catch (firstError) {
+            const firstMessage = firstError instanceof Error ? firstError.message : "";
+            const isChecksumError = firstMessage.toLowerCase().includes("checksum") ||
+                firstMessage.toLowerCase().includes("mismatch");
+            // Auto-retry on stale cache: clear cached connector and re-fetch
+            // from remote (skip local data-connectors dir which may be stale).
+            if (isChecksumError) {
+                try {
+                    const cacheDir = getConnectorCacheDir();
+                    const sourceCacheDir = path.join(cacheDir, source);
+                    await fsp.rm(sourceCacheDir, { recursive: true, force: true });
+                    const resolution = await fetchConnectorToCache(source, cacheDir, undefined);
+                    fetched = {
+                        connectorPath: resolution.connectorPath,
+                        logPath: "",
+                        version: resolution.version,
+                    };
+                }
+                catch (retryError) {
+                    const retryMessage = retryError instanceof Error
+                        ? retryError.message
+                        : `Could not fetch ${displayName} connector.`;
+                    const message = formatHumanSourceMessage(retryMessage, source, displayName);
+                    await updateSourceState(source, {
+                        connectorInstalled: false,
+                        lastRunAt: new Date().toISOString(),
+                        lastRunOutcome: CliOutcomeStatus.CONNECTOR_UNAVAILABLE,
+                        dataState: "none",
+                        lastError: message,
+                        lastResultPath: null,
+                        lastLogPath: getErrorLogPath(retryError),
+                    });
+                    renderer?.fail(`${displayName} connector could not be verified.`);
+                    renderer?.detail(`Try again later, or report: https://github.com/vana-com/data-connectors/issues`);
+                    emit.event({
+                        type: "outcome",
+                        status: CliOutcomeStatus.CONNECTOR_UNAVAILABLE,
+                        source,
+                        reason: message,
+                    });
+                    return 1;
+                }
+            }
+            else {
+                const message = formatHumanSourceMessage(firstMessage ||
+                    `No connector is available for ${displayName} right now.`, source, displayName);
+                await updateSourceState(source, {
+                    connectorInstalled: false,
+                    lastRunAt: new Date().toISOString(),
+                    lastRunOutcome: CliOutcomeStatus.CONNECTOR_UNAVAILABLE,
+                    dataState: "none",
+                    lastError: message,
+                    lastResultPath: null,
+                    lastLogPath: getErrorLogPath(firstError),
+                });
+                renderer?.fail(`${displayName} is not available.`);
+                renderer?.detail(`See what’s ready: vana sources`);
+                emit.event({
+                    type: "outcome",
+                    status: CliOutcomeStatus.CONNECTOR_UNAVAILABLE,
+                    source,
+                    reason: message,
+                });
+                return 1;
+            }
+        }
+        if (fetched.updated && fetched.previousVersion) {
+            trackActiveTelemetryEvent("connector_update_applied", {
+                source,
+                metadata: {
+                    previousVersion: fetched.previousVersion,
+                    connectorVersion: fetched.version,
+                },
+            });
+            renderer?.detail(`Updated connector (${fetched.previousVersion} → ${fetched.version}).`);
+        }
+        fetchLogPath = fetched.logPath;
+        const sourceDetails = registrySources.find((item) => item.id === source);
+        const resolution = {
+            source,
+            connectorPath: fetched.connectorPath,
+        };
+        emit.event({
+            type: "connector-resolved",
+            source: resolution.source,
+            connectorPath: resolution.connectorPath,
+            logPath: fetched.logPath,
+        });
+        trackActiveTelemetryEvent("connector_version_detected", {
+            source: resolution.source,
+            connectorVersion: fetched.version,
+        });
+        // --- Phase 3: Pre-connection validation (silent) ---
+        const profilePath = path.join(getBrowserProfilesDir(), `${path.basename(resolution.connectorPath, path.extname(resolution.connectorPath))}`);
+        if (sourceDetails?.authMode === "legacy" &&
+            !options.noInput &&
+            process.platform === "linux" &&
+            !process.env.DISPLAY &&
+            !process.env.WAYLAND_DISPLAY) {
+            const message = "This source needs a manual browser step, but no local display server is available.";
+            await updateSourceState(resolution.source, {
+                connectorInstalled: true,
+                sessionPresent: fs.existsSync(profilePath),
+                lastRunAt: new Date().toISOString(),
+                lastRunOutcome: CliOutcomeStatus.LEGACY_AUTH,
+                dataState: "none",
+                lastError: message,
+                lastResultPath: null,
+                lastLogPath: fetchLogPath ?? null,
+            });
+            renderer?.fail(`${displayName} requires a browser window, but no display is available.`);
+            renderer?.detail("Run this command in a desktop terminal.");
+            emit.event({
+                type: "outcome",
+                status: CliOutcomeStatus.LEGACY_AUTH,
+                source: resolution.source,
+                reason: "display_server_unavailable",
+            });
+            return 1;
+        }
+        await updateSourceState(resolution.source, {
+            connectorInstalled: true,
+            sessionPresent: fs.existsSync(profilePath),
+            lastError: null,
+            lastLogPath: fetchLogPath ?? null,
+        });
+        // --- Phase 4-5: Authentication + Collection ---
+        let finalStatus = CliOutcomeStatus.UNEXPECTED_INTERNAL_ERROR;
+        let finalDataState = "none";
+        let ingestFailureMessage = null;
+        let resultPath = getSourceResultPath(source);
+        let collectedResult = false;
+        let blockedByRequiredInput = false;
+        let ingestScopeResults;
+        // In IPC mode (--ipc), don’t provide an interactive callback.
+        // The runtime will write a pending-input file and poll for the
+        // response, letting an external agent handle credential collection.
+        const interactiveCallback = options.ipc
+            ? undefined
+            : async (needInput) => {
+                renderer?.pauseForPrompt();
+                // Show connector’s prompt message
+                if (renderer) {
+                    const promptMessage = needInput.message ?? `${displayName} needs your login.`;
+                    process.stderr.write(`\n${promptMessage}\n\n`);
+                }
+                const values = {};
+                try {
+                    for (const field of needInput.fields) {
+                        const isPasswordField = field.toLowerCase().includes("password");
+                        if (isPasswordField) {
+                            values[field] = await password({
+                                message: humanizeField(field),
+                                ...vanaPromptTheme,
+                            });
+                        }
+                        else {
+                            values[field] = await input({
+                                message: humanizeField(field),
+                                ...vanaPromptTheme,
+                            });
+                        }
+                    }
+                }
+                catch (error) {
+                    if (isPromptCancelled(error)) {
+                        throw new Error("__vana_prompt_cancelled__");
+                    }
+                    throw error;
+                }
+                if (renderer) {
+                    process.stderr.write("\n");
+                }
+                renderer?.resumeAfterPrompt();
+                return values;
+            };
+        for await (const event of runtime.runConnector({
+            connectorPath: resolution.connectorPath,
+            source: resolution.source,
+            noInput: options.ipc ? false : options.noInput,
+            onNeedInput: interactiveCallback,
+        })) {
+            emit.event(event);
+            if (event.logPath) {
+                runLogPath = event.logPath;
+            }
+            if (pendingExitCode !== null && event.type !== "collection-complete") {
+                continue;
+            }
+            if (event.type === "needs-input") {
+                if (options.noInput && !options.ipc) {
+                    blockedByRequiredInput = true;
+                }
+                await updateSourceState(resolution.source, {
+                    lastRunAt: new Date().toISOString(),
+                    lastRunOutcome: CliOutcomeStatus.NEEDS_INPUT,
+                    lastError: event.message ?? "Input required.",
+                    lastLogPath: event.logPath,
+                    connectionHealth: "needs_reauth",
+                    connectionHealthChangedAt: new Date().toISOString(),
+                    connectionHealthReason: `needs-input: ${event.message ?? "Input required."}`,
+                    connectionHealthRetryable: false,
+                });
+                emit.event({
+                    type: "outcome",
+                    status: CliOutcomeStatus.NEEDS_INPUT,
+                    source: resolution.source,
+                });
+                renderer?.fail(`${displayName} needs credentials. Run without --no-input to authenticate.`);
+                pendingExitCode = 1;
+            }
+            if (event.type === "progress-update") {
+                // Drive the renderer with scope information from the event
+                const scopeName = extractScopeName(event);
+                if (scopeName && renderer) {
+                    const isComplete = typeof event.message === "string" &&
+                        /^complete\b/i.test(event.message.trim());
+                    if (isComplete) {
+                        const detail = formatScopeDetail(event);
+                        renderer.scopeDone(scopeName, detail);
+                    }
+                    else {
+                        renderer.scopeActive(scopeName);
+                    }
+                }
+                continue;
+            }
+            if (event.type === "status-update") {
+                // Status updates are silent in the new design
+                continue;
+            }
+            if (event.type === "runtime-error") {
+                await updateSourceState(resolution.source, {
+                    lastRunAt: new Date().toISOString(),
+                    lastRunOutcome: CliOutcomeStatus.RUNTIME_ERROR,
+                    lastError: event.message ?? "Connector run failed.",
+                    lastLogPath: event.logPath,
+                    connectionHealth: "error",
+                    connectionHealthChangedAt: new Date().toISOString(),
+                    connectionHealthReason: `runtime-error: ${event.message ?? "Connector run failed."}`,
+                    connectionHealthRetryable: /timeout|ECONNREFUSED|ENOTFOUND|rate.?limit|50[234]|socket hang up/i.test(event.message ?? ""),
+                });
+                renderer?.fail(`Problem connecting ${displayName}.`);
+                renderer?.detail(event.message ?? "Connector run failed.");
+                renderer?.detail(`Retry: vana connect ${source}`);
+                emit.event({
+                    type: "outcome",
+                    status: CliOutcomeStatus.RUNTIME_ERROR,
+                    source: resolution.source,
+                });
+                pendingExitCode = 1;
+                continue;
+            }
+            if (event.type === "headed-required") {
+                // Silent — the browser opens automatically
+                continue;
+            }
+            if (event.type === "legacy-auth") {
+                await updateSourceState(resolution.source, {
+                    lastRunAt: new Date().toISOString(),
+                    lastRunOutcome: CliOutcomeStatus.LEGACY_AUTH,
+                    lastError: event.message ?? "Legacy authentication is required.",
+                    dataState: "none",
+                    lastResultPath: null,
+                    lastLogPath: event.logPath,
+                    connectionHealth: "needs_reauth",
+                    connectionHealthChangedAt: new Date().toISOString(),
+                    connectionHealthReason: `legacy-auth: ${event.message ?? "Legacy authentication is required."}`,
+                    connectionHealthRetryable: false,
+                });
+                renderer?.fail(`Manual step required for ${displayName}.`);
+                renderer?.detail(`Complete the browser step locally, then rerun vana connect ${source}.`);
+                emit.event({
+                    type: "outcome",
+                    status: CliOutcomeStatus.LEGACY_AUTH,
+                    source: resolution.source,
+                });
+                pendingExitCode = 1;
+            }
+            if (event.type === "collection-complete" && event.resultPath) {
+                if (blockedByRequiredInput) {
+                    continue;
+                }
+                // Check if the result is actually an error object
+                try {
+                    const raw = await fsp.readFile(event.resultPath, "utf8");
+                    const parsed = JSON.parse(raw);
+                    if (parsed &&
+                        typeof parsed === "object" &&
+                        "error" in parsed &&
+                        Object.keys(parsed).length <= 2) {
+                        // Connector returned an error, not real data
+                        const errorMsg = typeof parsed.error === "string"
+                            ? parsed.error
+                            : "Collection returned an error";
+                        await updateSourceState(source, {
+                            lastRunAt: new Date().toISOString(),
+                            lastRunOutcome: CliOutcomeStatus.RUNTIME_ERROR,
+                            connectionHealth: "error",
+                            connectionHealthChangedAt: new Date().toISOString(),
+                            connectionHealthReason: `error-result: ${errorMsg}`,
+                            connectionHealthRetryable: false,
+                            lastError: errorMsg,
+                            lastLogPath: runLogPath ?? fetchLogPath,
+                        });
+                        renderer?.fail(`Problem connecting ${displayName}.`);
+                        renderer?.detail(typeof parsed.error === "string"
+                            ? parsed.error
+                            : "The connector returned an error instead of data.");
+                        emit.event({
+                            type: "outcome",
+                            status: CliOutcomeStatus.RUNTIME_ERROR,
+                            source,
+                        });
+                        pendingExitCode = 1;
+                        continue;
+                    }
+                }
+                catch (parseError) {
+                    const msg = parseError instanceof Error ? parseError.message : "Unknown error";
+                    await updateSourceState(source, {
+                        lastError: `Failed to parse result file (${event.resultPath}): ${msg}`,
+                    });
+                }
+                collectedResult = true;
+                resultPath = event.resultPath;
+                const ingestEvents = await ingestResult(resolution.source, resultPath, target);
+                for (const ingestEvent of ingestEvents) {
+                    emit.event(ingestEvent);
+                }
+                const scopeResults = ingestEvents.find((e) => e.type === "ingest-complete" ||
+                    e.type === "ingest-partial" ||
+                    e.type === "ingest-failed")?.scopeResults;
+                const ingestCompleted = ingestEvents.some((ingestEvent) => ingestEvent.type === "ingest-complete");
+                const ingestPartial = ingestEvents.some((ingestEvent) => ingestEvent.type === "ingest-partial");
+                const ingestFailedEvent = ingestEvents.find((ingestEvent) => ingestEvent.type === "ingest-failed");
+                const ingestSkippedUnavailable = ingestEvents.some((ingestEvent) => ingestEvent.type === "ingest-skipped" &&
+                    ingestEvent.reason === "personal_server_unavailable");
+                if (ingestCompleted) {
+                    finalStatus = CliOutcomeStatus.CONNECTED_AND_INGESTED;
+                    finalDataState = "ingested_personal_server";
+                }
+                else if (ingestPartial) {
+                    finalStatus = CliOutcomeStatus.CONNECTED_AND_INGESTED;
+                    finalDataState = "ingested_personal_server";
+                }
+                else if (ingestFailedEvent?.type === "ingest-failed") {
+                    finalStatus = CliOutcomeStatus.INGEST_FAILED;
+                    finalDataState = "ingest_failed";
+                    ingestFailureMessage =
+                        ingestFailedEvent.message ?? "Personal Server sync failed.";
+                }
+                else if (ingestSkippedUnavailable) {
+                    finalStatus = CliOutcomeStatus.CONNECTED_LOCAL_ONLY;
+                    finalDataState = "ingest_unavailable";
+                }
+                else {
+                    finalStatus = CliOutcomeStatus.CONNECTED_LOCAL_ONLY;
+                    finalDataState = "collected_local";
+                }
+                // Store per-scope results in state
+                ingestScopeResults = scopeResults?.map((r) => ({
+                    scope: r.scope,
+                    status: r.status,
+                    syncedAt: r.status === "stored" ? new Date().toISOString() : undefined,
+                    error: r.error,
+                }));
+            }
+        }
+        if (pendingExitCode !== null && !collectedResult) {
+            return pendingExitCode;
+        }
+        if (!collectedResult) {
+            await updateSourceState(resolution.source, {
+                connectorInstalled: true,
+                sessionPresent: fs.existsSync(profilePath),
+                lastRunAt: new Date().toISOString(),
+                lastRunOutcome: CliOutcomeStatus.UNEXPECTED_INTERNAL_ERROR,
+                dataState: "none",
+                lastError: "Connector run ended without a result.",
+                lastResultPath: null,
+                lastLogPath: runLogPath ?? fetchLogPath ?? null,
+            });
+            renderer?.fail(`Problem connecting ${displayName}.`);
+            renderer?.detail("Connector run ended without a result.");
+            emit.event({
+                type: "outcome",
+                status: CliOutcomeStatus.UNEXPECTED_INTERNAL_ERROR,
+                source: resolution.source,
+                reason: "Connector run ended without a result.",
+            });
+            return 1;
+        }
+        await updateSourceState(resolution.source, {
+            connectorInstalled: true,
+            connectorVersion: fetched.version,
+            exportFrequency: fetched.exportFrequency,
+            sessionPresent: true,
+            lastRunAt: new Date().toISOString(),
+            lastCollectedAt: new Date().toISOString(),
+            lastRunOutcome: finalStatus,
+            dataState: finalDataState,
+            lastError: ingestFailureMessage,
+            lastResultPath: resultPath,
+            lastLogPath: runLogPath ?? fetchLogPath ?? setupLogPath ?? null,
+            connectionHealth: pendingExitCode !== null ? undefined : "healthy",
+            connectionHealthChangedAt: pendingExitCode !== null ? undefined : new Date().toISOString(),
+            connectionHealthReason: pendingExitCode !== null ? undefined : "collection-complete",
+            connectionHealthRetryable: undefined,
+            ingestScopes: ingestScopeResults,
+        });
+        // Build scope-aware success summary
+        const storedCount = ingestScopeResults?.filter((r) => r.status === "stored").length ?? 0;
+        const failedCount = ingestScopeResults?.filter((r) => r.status === "failed").length ?? 0;
+        const totalScopes = ingestScopeResults?.length ?? 0;
+        let successSummary;
+        if (finalStatus === CliOutcomeStatus.CONNECTED_AND_INGESTED &&
+            totalScopes > 0) {
+            if (failedCount === 0) {
+                successSummary = `Collected your ${displayName} data and synced it to your Personal Server.`;
+            }
+            else {
+                successSummary = `Collected your ${displayName} data. ${storedCount}/${totalScopes} scopes synced, ${failedCount} failed.`;
+            }
+        }
+        else if (finalStatus === CliOutcomeStatus.CONNECTED_AND_INGESTED) {
+            successSummary = `Collected your ${displayName} data and synced it to your Personal Server.`;
+        }
+        else if (finalDataState === "ingest_unavailable") {
+            successSummary = `Collected your ${displayName} data. Personal Server sync is pending.`;
+        }
+        else {
+            successSummary = `Collected your ${displayName} data and saved it locally.`;
+        }
+        // Auto-schedule collection if no schedule exists (non-blocking)
+        await maybeAutoSchedule(emit, options).catch(() => { });
+        // --- Phase 7: Success summary ---
+        renderer?.success(`Connected ${displayName}.`);
+        renderer?.detail(successSummary);
+        // Partial sync guidance
+        if (failedCount > 0 && storedCount > 0) {
+            renderer?.detail(`Retry: vana server sync`);
+        }
+        else if (finalDataState === "ingest_unavailable") {
+            renderer?.detail(`Pending sync will retry during scheduled collection.`);
+            renderer?.detail(`Retry now: vana server sync`);
+        }
+        // Journey-aware next step
+        const state = await readCliState();
+        const connectedSourceCount = Object.values(state.sources ?? {}).filter((s) => hasCollectedData(s?.dataState)).length;
+        renderer?.detail("");
+        if (connectedSourceCount > 1) {
+            renderer?.next("vana sources");
+        }
+        else {
+            renderer?.next(`vana data show ${source}`);
+        }
+        // Suggest skills if not yet installed
+        const installedSkills = await readInstalledSkills();
+        if (installedSkills.length === 0) {
+            renderer?.detail("Your coding agent can use this data — run `vana skills` to see how.");
+        }
+        renderer?.bell();
+        // Offer skill install on first successful connect (ask once)
+        if (!state.config?.skillsPromptCompleted &&
+            !options.json &&
+            !options.noInput &&
+            process.stdin.isTTY) {
+            await maybePromptSkillInstall(emit);
+        }
+        // Emit for --json consumers (unchanged)
+        emit.event({
+            type: "outcome",
+            status: finalStatus,
+            source: resolution.source,
+            resultPath,
+        });
+        if (pendingExitCode !== null) {
+            return pendingExitCode;
+        }
+        return 0;
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            error.message === "__vana_prompt_cancelled__") {
+            await updateSourceState(source, {
+                lastRunAt: new Date().toISOString(),
+                lastRunOutcome: CliOutcomeStatus.NEEDS_INPUT,
+                lastError: "Cancelled before input was completed.",
+                lastLogPath: runLogPath ?? null,
+            });
+            renderer?.fail("Cancelled.");
+            emit.event({
+                type: "outcome",
+                status: CliOutcomeStatus.NEEDS_INPUT,
+                source,
+                reason: "prompt_cancelled",
+            });
+            return 1;
+        }
+        const message = error instanceof Error ? error.message : "Unexpected error.";
+        renderer?.fail(`Problem connecting ${displayName}.`);
+        renderer?.detail(message);
+        renderer?.detail(`Retry: vana connect ${source}`);
+        emit.event({
+            type: "outcome",
+            status: CliOutcomeStatus.UNEXPECTED_INTERNAL_ERROR,
+            source,
+            reason: message,
+        });
+        return 1;
+    }
+    finally {
+        renderer?.cleanup();
+    }
+}
+async function runConnectEntry(options) {
+    const emit = createEmitter(options);
+    const sources = await loadRegistrySources();
+    const state = await readCliState();
+    const sourceMetadata = createSourceMetadataMap(sources);
+    const statuses = await gatherSourceStatuses(state.sources, sourceMetadata);
+    const statusMap = new Map(statuses.map((source) => [source.source, source]));
+    const enrichedSources = sources.map((source) => {
+        const status = statusMap.get(source.id);
+        return {
+            ...source,
+            dataState: status?.dataState,
+            lastRunOutcome: status?.lastRunOutcome ?? null,
+            sessionPresent: status?.sessionPresent ?? false,
+        };
+    });
+    const suggestedSource = enrichedSources.find((source) => source.authMode !== "legacy" && !hasCollectedData(source.dataState)) ??
+        enrichedSources.find((source) => source.authMode !== "legacy") ??
+        enrichedSources[0];
+    const missingSourceMessage = formatMissingConnectSourceMessage(suggestedSource);
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({
+            error: "source_required",
+            message: missingSourceMessage,
+            suggestedSource: suggestedSource
+                ? {
+                    id: suggestedSource.id,
+                    name: suggestedSource.name,
+                    authMode: suggestedSource.authMode,
+                }
+                : null,
+        })}\n`);
+        return 1;
+    }
+    if (options.noInput) {
+        emit.info(missingSourceMessage);
+        return 1;
+    }
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        emit.info(missingSourceMessage);
+        return 1;
+    }
+    if (enrichedSources.length === 0) {
+        emit.info("No sources are available right now.");
+        emit.info("Run `vana sources` to verify the local connector registry.");
+        return 1;
+    }
+    // Build inquirer-compatible choices from enriched sources
+    const choices = enrichedSources.map((item) => {
+        const connected = hasCollectedData(item.dataState);
+        const hint = connected
+            ? "connected"
+            : item.authMode === "legacy"
+                ? "browser login"
+                : undefined;
+        return {
+            value: item.id,
+            name: item.name,
+            description: hint,
+        };
+    });
+    try {
+        const source = await searchSelect({
+            message: "Choose a source to connect.",
+            choices,
+            ...vanaPromptTheme,
+        });
+        return runConnect(source, options);
+    }
+    catch (error) {
+        if (isPromptCancelled(error)) {
+            emit.info("Cancelled.");
+            return 1;
+        }
+        throw error;
+    }
+}
+async function runList(options) {
+    const result = await querySources();
+    const { sources: enrichedSources, recommendedSource } = result;
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+        return 0;
+    }
+    const emit = createEmitter(options);
+    emit.title("Available sources");
+    emit.blank();
+    if (enrichedSources.length === 0) {
+        emit.info("No sources are available right now.");
+    }
+    else {
+        const connectedSources = enrichedSources.filter((source) => hasCollectedData(source.dataState));
+        const unconnectedSources = enrichedSources.filter((source) => !hasCollectedData(source.dataState));
+        // Connected sources are always shown expanded
+        if (connectedSources.length > 0) {
+            emit.section("Connected");
+            for (const source of connectedSources) {
+                const badges = [];
+                if (source.dataState === "ingested_personal_server") {
+                    badges.push({ text: "synced", tone: "success" });
+                }
+                else if (source.dataState === "ingest_failed") {
+                    badges.push({ text: "sync failed", tone: "warning" });
+                }
+                else {
+                    badges.push({ text: "local", tone: "muted" });
+                }
+                emit.sourceTitle(source.name, badges);
+                emit.detail(`Inspect with ${emit.code(`vana data show ${source.id}`)}.`);
+            }
+            emit.blank();
+            emit.section("Available");
+        }
+        for (const source of unconnectedSources) {
+            const badges = [];
+            if (recommendedSource?.id === source.id &&
+                recommendedSource.authMode !== "legacy") {
+                badges.push({ text: "recommended", tone: "accent" });
+            }
+            emit.sourceTitle(source.name, badges);
+            if (source.description) {
+                emit.detail(cleanDescription(source.description));
+            }
+        }
+        if (recommendedSource) {
+            emit.blank();
+            emit.next(`vana connect ${recommendedSource.id}`);
+        }
+    }
+    return 0;
+}
+async function runStatus(options) {
+    const { status, nextSteps } = await queryStatus();
+    const state = await readCliState();
+    // Build per-source health map from stored state
+    const sourceHealthMap = {};
+    for (const [sourceId, stored] of Object.entries(state.sources)) {
+        if (stored) {
+            sourceHealthMap[sourceId] = {
+                connectionHealth: stored.connectionHealth,
+                connectionHealthChangedAt: stored.connectionHealthChangedAt,
+                connectionHealthReason: stored.connectionHealthReason,
+                connectionHealthRetryable: stored.connectionHealthRetryable,
+                lastCollectedAt: stored.lastCollectedAt,
+                lastLogPath: stored.lastLogPath,
+                lastError: stored.lastError,
+            };
+        }
+    }
+    if (options.json) {
+        const jsonAuthCreds = loadCredentials();
+        const compactJson = {
+            runtime: status.runtime,
+            personalServer: status.personalServer,
+            personalServerUrl: status.personalServerUrl,
+            pendingSyncCount: status.pendingSyncCount ?? 0,
+            auth: jsonAuthCreds
+                ? {
+                    authenticated: !isExpired(jsonAuthCreds),
+                    address: jsonAuthCreds.account.address,
+                    expires_at: jsonAuthCreds.account.expires_at,
+                }
+                : { authenticated: false },
+            sources: {
+                connected: status.summary?.connectedCount ?? 0,
+                needsAttention: status.summary?.needsAttentionCount ?? 0,
+            },
+            sourceHealth: sourceHealthMap,
+            next: nextSteps[0] ?? null,
+        };
+        process.stdout.write(`${JSON.stringify(compactJson)}\n`);
+        return 0;
+    }
+    const emit = createEmitter(options);
+    const registrySources = await loadRegistrySources();
+    const sourceLabels = createSourceLabelMap(registrySources);
+    emit.title("Vana Connect");
+    emit.blank();
+    emit.keyValue("Runtime", status.runtime, toneForRuntime(status.runtime));
+    if (status.personalServer === "available") {
+        emit.keyValue("Personal Server", status.personalServerUrl ?? "connected", "success");
+    }
+    else {
+        emit.keyValue("Personal Server", "not connected", "warning");
+    }
+    // Auth state
+    const authCreds = loadCredentials();
+    if (authCreds && !isExpired(authCreds)) {
+        emit.keyValue("Account", authCreds.account.address, "success");
+        emit.keyValue("Auth", `Authenticated (expires in ${formatExpiresIn(authCreds.account.expires_at)})`, "success");
+    }
+    else {
+        emit.keyValue("Account", "Not logged in", "muted");
+        emit.keyValue("Auth", "Run `vana login` to authenticate", "muted");
+    }
+    const trackedSources = status.sources.filter(shouldDisplaySourceInStatus);
+    const attentionSources = trackedSources
+        .filter(isSourceAttention)
+        .sort(compareAttentionPriority);
+    const healthySources = trackedSources
+        .filter((source) => !isSourceAttention(source))
+        .sort(compareSourceStatusOrder);
+    const sourceParts = [
+        healthySources.length > 0
+            ? `${healthySources.length} healthy`
+            : trackedSources.length > 0
+                ? "none healthy"
+                : "none connected",
+        ...(attentionSources.length > 0
+            ? [
+                `${attentionSources.length} need${attentionSources.length === 1 ? "s" : ""} attention`,
+            ]
+            : []),
+    ];
+    emit.keyValue("Sources", sourceParts.join(", "), attentionSources.length > 0 && healthySources.length > 0
+        ? "warning"
+        : healthySources.length > 0
+            ? "success"
+            : "muted");
+    if ((status.pendingSyncCount ?? 0) > 0) {
+        emit.keyValue("Pending sync", `${status.pendingSyncCount} dataset(s)`, "warning");
+    }
+    if (attentionSources.length > 0) {
+        emit.blank();
+        emit.section(formatCountLabel("Needs attention", attentionSources.length));
+        for (const source of attentionSources) {
+            emitHumanStatusSource(emit, source, sourceLabels);
+        }
+    }
+    if (healthySources.length > 0) {
+        emit.blank();
+        emit.section(formatCountLabel("Healthy", healthySources.length));
+        for (const source of healthySources) {
+            emitHumanStatusSource(emit, source, sourceLabels);
+        }
+    }
+    if (nextSteps.length > 0) {
+        emit.blank();
+        const command = extractCommand(nextSteps[0]);
+        if (command) {
+            emit.next(command);
+        }
+        else {
+            emit.detail(`Next: ${nextSteps[0]}`);
+        }
+    }
+    return 0;
+}
+function shouldDisplaySourceInStatus(source) {
+    return (source.installed ||
+        Boolean(source.lastRunOutcome) ||
+        source.dataState !== "none" ||
+        Boolean(source.connectionHealth));
+}
+function emitHumanStatusSource(emit, source, sourceLabels) {
+    const displayName = displaySource(source.source, sourceLabels);
+    const presentation = getHumanStatusPresentation(source);
+    const staleTag = source.isOverdue ? ` ${emit.badge("stale", "warning")}` : "";
+    const collectedAgo = source.lastCollectedAt
+        ? `collected ${formatRelativeTime(source.lastCollectedAt)}`
+        : "";
+    emit.keyValue(`  ${displayName}`, `${presentation.label}${staleTag}${collectedAgo ? `     ${collectedAgo}` : ""}`, presentation.tone);
+    const detail = formatHumanStatusDetail(source);
+    if (detail) {
+        emit.detail(`  \u21b3 ${detail}`);
+    }
+}
+function getHumanStatusPresentation(source) {
+    if (source.dataState === "ingest_failed") {
+        return { label: "sync failed", tone: "warning" };
+    }
+    if (source.dataState === "ingest_unavailable") {
+        return { label: "pending sync", tone: "warning" };
+    }
+    if (source.connectionHealth === "needs_reauth") {
+        return { label: "needs login", tone: "warning" };
+    }
+    if (source.connectionHealth === "error") {
+        return { label: "error", tone: "error" };
+    }
+    const presentation = getSourceStatusPresentation(source);
+    if (presentation.label === "needs input") {
+        return { label: "needs login", tone: presentation.tone };
+    }
+    return presentation;
+}
+function formatHumanStatusDetail(source) {
+    if (source.dataState === "ingest_failed") {
+        return formatSyncFailureSummary(source);
+    }
+    if (source.dataState === "ingest_unavailable") {
+        return "Personal Server unavailable. Pending sync will retry during scheduled collection. Run `vana server sync`.";
+    }
+    if (source.connectionHealth === "needs_reauth" ||
+        source.lastRunOutcome === CliOutcomeStatus.NEEDS_INPUT) {
+        return `Authentication required. Run \`vana connect ${source.source}\`.`;
+    }
+    if (source.lastRunOutcome === CliOutcomeStatus.LEGACY_AUTH) {
+        return `Manual auth step required. Run \`vana connect ${source.source}\`.`;
+    }
+    if (source.connectionHealth === "error") {
+        const message = formatHealthMessage(source.connectionHealthReason);
+        return `${message ?? "Collection failed."} Run \`vana connect ${source.source}\`.`;
+    }
+    if (source.lastRunOutcome === CliOutcomeStatus.RUNTIME_ERROR) {
+        return `${humanizeIssue(source.lastError ?? "Collection failed")}. Run \`vana connect ${source.source}\`.`;
+    }
+    if (source.lastRunOutcome === CliOutcomeStatus.CONNECTOR_UNAVAILABLE) {
+        return "No connector available. Run `vana sources`.";
+    }
+    return null;
+}
+function formatSyncFailureSummary(source) {
+    const failedScopes = source.ingestScopes?.filter((scope) => scope.status === "failed") ?? [];
+    if (failedScopes.length === 0) {
+        return `Personal Server sync failed. Run \`vana connect ${source.source}\`.`;
+    }
+    const groupedFailures = new Map();
+    for (const failedScope of failedScopes) {
+        const summary = humanizeIssue(failedScope.error ?? "Sync failed");
+        groupedFailures.set(summary, (groupedFailures.get(summary) ?? 0) + 1);
+    }
+    const entries = Array.from(groupedFailures.entries());
+    if (entries.length === 1) {
+        const [summary, count] = entries[0];
+        return `${summary}${count > 1 ? ` for ${count} scopes` : ""}. Run \`vana connect ${source.source}\`.`;
+    }
+    const summaryParts = entries.map(([summary, count]) => count > 1 ? `${summary} (${count})` : summary);
+    return `${failedScopes.length} scopes failed to sync: ${summaryParts.join("; ")}. Run \`vana connect ${source.source}\`.`;
+}
+async function runDoctor(options) {
+    const payload = await queryDoctor();
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify(payload)}\n`);
+        return 0;
+    }
+    const sourceLabels = createSourceLabelMap(await loadRegistrySources());
+    const { recentSources } = payload;
+    const attentionSources = recentSources.filter((source) => rankSourceStatus(source) <= 4);
+    const emit = createEmitter(options);
+    emit.title("Vana Connect doctor");
+    emit.section("Summary");
+    emit.keyValue("CLI", payload.cliVersion, "muted");
+    emit.keyValue("Channel", payload.channel, "muted");
+    emit.keyValue("Install", formatInstallMethodLabel(payload.installMethod), "muted");
+    emit.keyValue("Runtime", payload.runtime, toneForRuntime(payload.runtime));
+    emit.keyValue("Personal Server", payload.personalServer, payload.personalServer === "available" ? "success" : "warning");
+    emit.keyValue("Tracked sources", String(payload.summary.trackedSourceCount), "muted");
+    emit.keyValue("Attention", String(payload.summary.attentionCount), payload.summary.attentionCount > 0 ? "warning" : "muted");
+    emit.keyValue("Connected", String(payload.summary.connectedCount), payload.summary.connectedCount > 0 ? "success" : "muted");
+    emit.blank();
+    emit.section("Checks");
+    for (const check of payload.checks) {
+        const tone = check.status === "ok"
+            ? "success"
+            : check.status === "warn"
+                ? "warning"
+                : "error";
+        emit.keyValue(check.label, check.detail, tone);
+    }
+    if (recentSources.length > 0) {
+        emit.blank();
+        emit.section(attentionSources.length > 0
+            ? "Needs attention"
+            : "Recent source activity");
+        for (const source of attentionSources.length > 0
+            ? attentionSources
+            : recentSources) {
+            const status = getSourceStatusPresentation(source);
+            const badges = [];
+            badges.push({ text: status.label, tone: status.tone });
+            emit.sourceTitle(displaySource(source.source, sourceLabels), badges);
+            const details = formatSourceStatusDetails(source);
+            for (const detail of details) {
+                if (detail.kind === "row") {
+                    emit.keyValue(detail.label, detail.value, detail.tone ?? "muted");
+                }
+                else {
+                    emit.detail(humanizeIssue(detail.message));
+                }
+            }
+        }
+    }
+    emit.blank();
+    emit.section("Paths");
+    emit.keyValue("Executable", formatDisplayPath(payload.paths.executable), "muted");
+    if (payload.paths.appRoot) {
+        emit.keyValue("App root", formatDisplayPath(payload.paths.appRoot), "muted");
+    }
+    emit.keyValue("Data home", formatDisplayPath(payload.paths.dataHome), "muted");
+    emit.keyValue("State file", formatDisplayPath(payload.paths.stateFile), "muted");
+    emit.keyValue("Connector cache", formatDisplayPath(payload.paths.connectorCache), "muted");
+    emit.keyValue("Browser profiles", formatDisplayPath(payload.paths.browserProfiles), "muted");
+    emit.keyValue("Logs", formatDisplayPath(payload.paths.logs), "muted");
+    emit.blank();
+    emit.section("Lifecycle");
+    emit.keyValue("Upgrade", payload.lifecycle.upgrade, "muted");
+    emit.keyValue("Uninstall", payload.lifecycle.uninstall, "muted");
+    if (payload.nextSteps.length > 0) {
+        emit.blank();
+        const command = extractCommand(payload.nextSteps[0]);
+        if (command) {
+            emit.next(command);
+        }
+        else {
+            emit.detail(`Next: ${payload.nextSteps[0]}`);
+        }
+    }
+    return 0;
+}
+async function runServerStatus(options) {
+    const emit = createEmitter(options);
+    const target = await detectPersonalServerTarget();
+    const state = await readCliState();
+    // Count scopes from state
+    let totalScopeCount = 0;
+    for (const stored of Object.values(state.sources)) {
+        if (stored?.ingestScopes) {
+            totalScopeCount += stored.ingestScopes.filter((s) => s.status === "stored").length;
+        }
+    }
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({
+            state: target.state,
+            url: target.url,
+            source: target.source,
+            health: target.health,
+            scopeCount: totalScopeCount,
+        })}\n`);
+        return 0;
+    }
+    emit.title("Personal Server");
+    emit.blank();
+    if (target.url) {
+        const urlSuffix = target.source === "scan"
+            ? "(auto-detected)"
+            : target.source === "config"
+                ? "(saved)"
+                : target.source === "auth"
+                    ? "(from vana login)"
+                    : target.source === "env"
+                        ? "(from VANA_PERSONAL_SERVER_URL)"
+                        : `(${target.source ?? "unknown"})`;
+        emit.keyValue("URL", `${target.url} ${urlSuffix}`, "muted");
+    }
+    const stateLabel = target.state === "available" ? "healthy" : "Not connected";
+    emit.keyValue("Status", stateLabel, target.state === "available" ? "success" : "warning");
+    if (target.health) {
+        emit.keyValue("Version", target.health.version, "muted");
+    }
+    if (totalScopeCount > 0) {
+        emit.keyValue("Scopes", `${totalScopeCount} stored`, "muted");
+    }
+    if (target.source && !target.url) {
+        const sourceLabel = {
+            config: "Saved config",
+            env: "VANA_PERSONAL_SERVER_URL",
+            scan: "Localhost scan",
+        };
+        emit.keyValue("Resolved via", sourceLabel[target.source] ?? target.source, "muted");
+    }
+    if (target.health) {
+        emit.keyValue("Uptime", formatUptime(target.health.uptime), "muted");
+        if (target.health.owner) {
+            emit.keyValue("Owner", target.health.owner, "muted");
+        }
+    }
+    if (target.source === "scan" && target.url) {
+        emit.blank();
+        emit.detail(`Save with ${emit.code(`vana server set-url ${target.url}`)}.`);
+    }
+    if (target.state !== "available") {
+        emit.blank();
+        emit.next("vana server set-url <url>");
+    }
+    emit.blank();
+    emit.detail(`More: ${emit.code("vana server sync")} | ${emit.code("vana server data")} | ${emit.code("vana server --help")}`);
+    return 0;
+}
+async function runServerSetUrl(url, options) {
+    const emit = createEmitter(options);
+    try {
+        new URL(url);
+    }
+    catch {
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({ ok: false, error: "Invalid URL" })}\n`);
+        }
+        else {
+            emit.info(`Invalid URL: ${url}`);
+        }
+        return 1;
+    }
+    await updateCliConfig({ personalServerUrl: url });
+    const target = await detectPersonalServerTarget();
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({
+            ok: true,
+            url,
+            reachable: target.state === "available",
+            health: target.health,
+        })}\n`);
+        return 0;
+    }
+    emit.info(`Saved Personal Server URL: ${url}`);
+    if (target.state === "available") {
+        emit.info(`Server is reachable (${target.health?.version ?? "unknown version"}).`);
+    }
+    else {
+        emit.info("Server is not reachable yet. It will be used when available.");
+    }
+    return 0;
+}
+async function runServerClearUrl(options) {
+    const emit = createEmitter(options);
+    const config = await readCliConfig();
+    if (!config.personalServerUrl) {
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({ ok: true, cleared: false })}\n`);
+        }
+        else {
+            const target = await detectPersonalServerTarget();
+            if (target.source === "scan" && target.url) {
+                emit.info("No saved URL to clear. Current connection is auto-detected on localhost.");
+                emit.info(`Run ${emit.code("vana server set-url <url>")} to save a specific URL.`);
+            }
+            else {
+                emit.info("No saved Personal Server URL to clear.");
+            }
+        }
+        return 0;
+    }
+    await updateCliConfig({ personalServerUrl: undefined });
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({ ok: true, cleared: true })}\n`);
+    }
+    else {
+        emit.info("Cleared saved Personal Server URL.");
+    }
+    return 0;
+}
+export function formatUptime(seconds) {
+    if (seconds < 60)
+        return `${Math.round(seconds)}s`;
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)}m`;
+    if (seconds < 86400) {
+        const hours = Math.floor(seconds / 3600);
+        const minutes = Math.floor((seconds % 3600) / 60);
+        return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
+    }
+    const days = Math.floor(seconds / 86400);
+    const hours = Math.floor((seconds % 86400) / 3600);
+    return hours > 0 ? `${days}d ${hours}h` : `${days}d`;
+}
+async function runSetup(options) {
+    const emit = createEmitter(options);
+    const runtime = new ManagedPlaywrightRuntime();
+    const registrySources = await loadRegistrySources();
+    const suggestedSource = registrySources.find((source) => source.authMode !== "legacy") ??
+        registrySources[0];
+    emit.title("Vana Connect setup");
+    emit.section("Runtime");
+    if (runtime.state === "installed") {
+        emit.info("The local runtime is already installed.");
+        if (runtime.runtimePath) {
+            emit.keyValue("Browser", formatDisplayPath(runtime.runtimePath), "muted");
+        }
+        emit.blank();
+        if (suggestedSource) {
+            emit.next(`vana connect ${suggestedSource.id}`);
+        }
+        else {
+            emit.next("vana connect");
+        }
+        emit.event({ type: "setup-check", runtime: runtime.state });
+        return 0;
+    }
+    try {
+        const result = await runtime.ensureInstalled(Boolean(options.yes));
+        emit.success("Runtime ready.");
+        if (result.logPath) {
+            emit.detail(`Setup log: ${formatDisplayPath(result.logPath)}`);
+        }
+        emit.blank();
+        if (suggestedSource) {
+            emit.next(`vana connect ${suggestedSource.id}`);
+        }
+        else {
+            emit.next("vana connect");
+        }
+        emit.event({
+            type: "setup-complete",
+            runtime: result.runtime,
+            logPath: result.logPath,
+        });
+        return 0;
+    }
+    catch (error) {
+        const message = error instanceof Error
+            ? error.message
+            : "Vana Connect could not finish installing the local runtime.";
+        emit.info(message);
+        emit.event({
+            type: "outcome",
+            status: CliOutcomeStatus.RUNTIME_ERROR,
+            reason: message,
+        });
+        return 1;
+    }
+}
+async function runDataList(options) {
+    const result = await queryDataList();
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+        return 0;
+    }
+    const { datasets: datasetRecords } = result;
+    const registrySources = await loadRegistrySources();
+    const emit = createEmitter(options);
+    if (datasetRecords.length === 0) {
+        const suggestedSource = registrySources.find((source) => source.authMode !== "legacy") ??
+            registrySources[0];
+        emit.title("Collected data");
+        emit.blank();
+        emit.info("  No datasets yet.");
+        emit.blank();
+        if (suggestedSource) {
+            emit.next(`vana connect ${suggestedSource.id}`);
+        }
+        else {
+            emit.next("vana connect");
+        }
+        return 0;
+    }
+    emit.title(datasetRecords.length > 0
+        ? `Collected data (${datasetRecords.length})`
+        : "Collected data");
+    emit.blank();
+    emit.info(joinOverviewParts([
+        formatCountLabel("dataset", datasetRecords.length),
+        formatCountLabel("local only", datasetRecords.filter((dataset) => dataset.dataState !== "ingested_personal_server").length),
+        formatCountLabel("synced", datasetRecords.filter((dataset) => dataset.dataState === "ingested_personal_server").length),
+        datasetRecords.some((dataset) => dataset.dataState === "ingest_failed")
+            ? formatCountLabel("sync failed", datasetRecords.filter((dataset) => dataset.dataState === "ingest_failed").length)
+            : "",
+    ]));
+    emit.blank();
+    datasetRecords.forEach((dataset, index) => {
+        if (index > 0) {
+            emit.blank();
+        }
+        const badges = dataset.dataState === "ingested_personal_server"
+            ? [{ text: "synced", tone: "success" }]
+            : dataset.dataState === "ingest_failed"
+                ? [{ text: "sync failed", tone: "warning" }]
+                : [{ text: "local", tone: "muted" }];
+        emit.sourceTitle(dataset.name ?? displaySource(dataset.source), badges);
+        if (dataset.summary) {
+            for (const line of dataset.summary.lines) {
+                emit.detail(line);
+            }
+        }
+        if (dataset.dataState === "ingested_personal_server") {
+            emit.keyValue("State", "Synced to Personal Server", "success");
+        }
+        else if (dataset.dataState === "ingest_failed") {
+            emit.keyValue("State", "Saved locally, sync failed", "warning");
+        }
+        else {
+            emit.keyValue("State", "Saved locally", "muted");
+        }
+        if (dataset.lastRunAt) {
+            emit.keyValue("Updated", formatTimestamp(dataset.lastRunAt), "muted");
+        }
+        if (dataset.path) {
+            emit.keyValue("Path", formatDisplayPath(dataset.path), "muted");
+        }
+    });
+    emit.blank();
+    if (datasetRecords.length > 0) {
+        emit.next(`vana data show ${datasetRecords[0].source}`);
+    }
+    return 0;
+}
+async function runDataShow(source, options) {
+    const result = await queryDataShow(source);
+    if (!result.ok) {
+        if (result.error === "dataset_not_found") {
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify({
+                    error: result.error,
+                    source: result.source,
+                    message: result.message,
+                    nextSteps: result.nextSteps,
+                })}\n`);
+            }
+            else {
+                const emit = createEmitter(options);
+                emit.info(result.message);
+                emit.blank();
+                emit.next(`vana connect ${source}`);
+            }
+            return 1;
+        }
+        // dataset_read_failed
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({ error: result.error, source: result.source, path: result.path, message: result.message })}\n`);
+        }
+        else {
+            createEmitter(options).info(result.message);
+        }
+        return 1;
+    }
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({
+            source: result.source,
+            name: result.name,
+            path: result.path,
+            summary: result.summary,
+            lastRunAt: result.lastRunAt,
+            dataState: result.dataState,
+            nextSteps: result.nextSteps,
+            data: result.data,
+        })}\n`);
+        return 0;
+    }
+    const emit = createEmitter(options);
+    const state = await readCliState();
+    const record = state.sources[source];
+    emit.title(`${result.name} data`);
+    emit.blank();
+    if (result.summary) {
+        for (const line of result.summary.lines) {
+            emit.detail(line);
+        }
+        emit.blank();
+    }
+    emit.keyValue("Path", formatDisplayPath(result.path), "muted");
+    if (record?.lastRunAt) {
+        emit.keyValue("Updated", formatTimestamp(record.lastRunAt), "muted");
+    }
+    if (record?.dataState === "ingested_personal_server") {
+        emit.keyValue("State", "Synced to Personal Server", "success");
+    }
+    else if (record?.dataState === "ingest_failed") {
+        emit.keyValue("State", "Saved locally, sync failed", "warning");
+    }
+    else {
+        emit.keyValue("State", "Saved locally", "muted");
+    }
+    emit.blank();
+    if (result.datasetCount > 1) {
+        emit.next("vana data list");
+    }
+    else {
+        emit.next(`vana connect ${source}`);
+    }
+    return 0;
+}
+async function runDataPath(source, options) {
+    const sourceLabels = createSourceLabelMap(await loadRegistrySources());
+    const state = await readCliState();
+    const resultPath = state.sources[source]?.lastResultPath;
+    if (!resultPath) {
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({
+                error: "dataset_not_found",
+                source,
+                name: displaySource(source, sourceLabels),
+                message: `No collected dataset found for ${displaySource(source, sourceLabels)}. Run \`vana connect ${source}\` first.`,
+            })}\n`);
+        }
+        else {
+            createEmitter(options).info(`No collected dataset found for ${displaySource(source, sourceLabels)}. Run \`vana connect ${source}\` first.`);
+        }
+        return 1;
+    }
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({
+            source,
+            name: displaySource(source, sourceLabels),
+            path: resultPath,
+            lastRunAt: state.sources[source]?.lastRunAt ?? null,
+            dataState: state.sources[source]?.dataState ?? null,
+            nextSteps: [
+                `Inspect the dataset with \`vana data show ${source}\`.`,
+                `Reconnect ${displaySource(source, sourceLabels)} with \`vana connect ${source}\`.`,
+            ],
+        })}\n`);
+    }
+    else {
+        process.stdout.write(`${formatDisplayPath(resultPath)}\n`);
+    }
+    return 0;
+}
+async function runLogs(source, options) {
+    const sourceLabels = createSourceLabelMap(await loadRegistrySources());
+    const state = await readCliState();
+    const records = Object.entries(state.sources)
+        .filter(([, entry]) => Boolean(entry?.lastLogPath))
+        .map(([sourceId, entry]) => ({
+        source: sourceId,
+        name: displaySource(sourceId, sourceLabels),
+        path: entry?.lastLogPath ?? "",
+        lastRunAt: entry?.lastRunAt ?? null,
+        lastRunOutcome: entry?.lastRunOutcome ?? null,
+        dataState: (entry?.dataState === "collected_local" ||
+            entry?.dataState === "ingested_personal_server" ||
+            entry?.dataState === "ingest_failed"
+            ? entry.dataState
+            : null),
+    }))
+        .sort(compareLogRecordOrder);
+    const logSummary = {
+        attentionCount: records.filter((record) => isAttentionLog(record.lastRunOutcome, record.dataState)).length,
+        successfulCount: records.filter((record) => record.dataState === "collected_local" ||
+            record.dataState === "ingested_personal_server").length,
+        localCount: records.filter((record) => record.dataState === "collected_local").length,
+        syncedCount: records.filter((record) => record.dataState === "ingested_personal_server").length,
+    };
+    if (source) {
+        const match = records.find((record) => record.source === source);
+        if (!match) {
+            const payload = {
+                error: "log_not_found",
+                source,
+                message: `No stored run log found for ${displaySource(source, sourceLabels)}.`,
+                nextSteps: [
+                    `Run \`vana connect ${source}\` to create a new log.`,
+                    ...(records.length > 0
+                        ? ["Run `vana logs` to inspect other logs."]
+                        : []),
+                ],
+            };
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify(payload)}\n`);
+            }
+            else {
+                const emit = createEmitter(options);
+                emit.info(payload.message);
+                emit.blank();
+                emit.next(`vana connect ${source}`);
+            }
+            return 1;
+        }
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify(match)}\n`);
+        }
+        else {
+            process.stdout.write(`${formatDisplayPath(match.path)}\n`);
+        }
+        return 0;
+    }
+    const nextSteps = buildLogsNextSteps(records);
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({
+            count: records.length,
+            latestLog: records[0] ?? null,
+            nextSteps,
+            summary: logSummary,
+            logs: records,
+        })}\n`);
+        return 0;
+    }
+    const emit = createEmitter(options);
+    emit.title(records.length > 0 ? `Run logs (${records.length})` : "Run logs");
+    emit.blank();
+    if (records.length === 0) {
+        emit.info("No stored run logs yet.");
+        emit.blank();
+        emit.next("vana connect");
+        return 0;
+    }
+    emit.info(joinOverviewParts([
+        logSummary.attentionCount > 0
+            ? formatCountLabel("need attention", logSummary.attentionCount)
+            : "",
+        logSummary.successfulCount > 0
+            ? formatCountLabel("successful", logSummary.successfulCount)
+            : "",
+        logSummary.localCount > 0
+            ? formatCountLabel("local", logSummary.localCount)
+            : "",
+        logSummary.syncedCount > 0
+            ? formatCountLabel("synced", logSummary.syncedCount)
+            : "",
+    ]));
+    emit.blank();
+    const groups = [
+        {
+            title: "Needs attention",
+            items: records.filter((record) => isAttentionLog(record.lastRunOutcome, record.dataState)),
+        },
+        {
+            title: "Successful runs",
+            items: records.filter((record) => !isAttentionLog(record.lastRunOutcome, record.dataState)),
+        },
+    ].filter((group) => group.items.length > 0);
+    groups.forEach((group, groupIndex) => {
+        if (groupIndex > 0) {
+            emit.blank();
+        }
+        emit.section(formatCountLabel(group.title, group.items.length));
+        for (const record of group.items) {
+            emit.sourceTitle(record.name, [
+                {
+                    text: formatLogOutcomeLabel(record.lastRunOutcome, record.dataState),
+                    tone: toneForLogOutcome(record.lastRunOutcome, record.dataState),
+                },
+            ]);
+            emit.keyValue("Path", formatDisplayPath(record.path), "muted");
+            if (record.lastRunAt) {
+                emit.keyValue("Updated", formatTimestamp(record.lastRunAt), "muted");
+            }
+        }
+    });
+    emit.blank();
+    if (nextSteps.length > 0) {
+        const command = extractCommand(nextSteps[0]);
+        if (command) {
+            emit.next(command);
+        }
+        else {
+            emit.detail(`Next: ${nextSteps[0]}`);
+        }
+    }
+    return 0;
+}
+async function runSourceDetail(source, options) {
+    const emit = createEmitter(options);
+    const registrySources = await loadRegistrySources();
+    const state = await readCliState();
+    const match = registrySources.find((s) => s.id === source || s.name.toLowerCase() === source.toLowerCase());
+    if (!match) {
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({ error: "unknown_source", source, message: `Unknown source: ${source}. Run \`vana sources\` to see available options.` })}\n`);
+        }
+        else {
+            emit.info(`Unknown source: ${source}. Run \`vana sources\` to see available options.`);
+        }
+        return 1;
+    }
+    const stored = state.sources[match.id];
+    const metadata = await readCachedConnectorMetadata(match.id, getConnectorCacheDir());
+    const scopes = metadata?.scopes ?? [];
+    const sourceStatus = stored
+        ? {
+            source: match.id,
+            installed: Boolean(stored.connectorInstalled),
+            sessionPresent: stored.sessionPresent ?? false,
+            lastRunOutcome: stored.lastRunOutcome ?? null,
+            dataState: stored.dataState,
+        }
+        : undefined;
+    const badge = sourceStatus ? getSourceBadge(sourceStatus) : undefined;
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({
+            id: match.id,
+            name: match.name,
+            company: match.company,
+            description: match.description,
+            version: match.version ?? stored?.connectorVersion,
+            exportFrequency: match.exportFrequency ?? stored?.exportFrequency,
+            authMode: match.authMode,
+            scopes,
+            scopeLabels: scopes.map((s) => s.label),
+            connectorVersion: stored?.connectorVersion,
+            lastCollectedAt: stored?.lastCollectedAt,
+            dataState: stored?.dataState,
+        })}\n`);
+        return 0;
+    }
+    const iconPrefix = await renderIconInline(match.id);
+    const badgeList = [];
+    if (badge && badge.label !== "new") {
+        badgeList.push({ text: badge.label, tone: badge.style });
+    }
+    emit.sourceTitle(`${iconPrefix}${match.name}`, badgeList);
+    emit.blank();
+    if (match.description) {
+        emit.info(cleanDescription(match.description));
+        emit.blank();
+    }
+    if (scopes.length > 0) {
+        emit.section("Collects");
+        for (const scope of scopes) {
+            if (scope.description) {
+                emit.keyValue(scope.label, cleanDescription(scope.description), "muted");
+            }
+            else {
+                emit.bullet(scope.label);
+            }
+        }
+    }
+    if (stored?.connectorVersion &&
+        match.version &&
+        stored.connectorVersion !== match.version) {
+        emit.blank();
+        emit.detail(`A newer connector version is available (${match.version}). Reconnect to update.`);
+    }
+    emit.blank();
+    emit.next(`vana connect ${match.id}`);
+    return 0;
+}
+async function runCollect(source, options) {
+    const emit = createEmitter(options);
+    const state = await readCliState();
+    const stored = state.sources[source];
+    if (!stored || !stored.connectorInstalled) {
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({
+                error: "not_previously_connected",
+                source,
+                message: `Source "${source}" has not been connected yet. Run \`vana connect ${source}\` first.`,
+            })}\n`);
+        }
+        else {
+            emit.info(`Source "${source}" has not been connected yet. Run \`vana connect ${source}\` first.`);
+        }
+        return 1;
+    }
+    return runConnect(source, options);
+}
+function isPendingSyncDataState(dataState) {
+    return dataState === "collected_local" || dataState === "ingest_unavailable";
+}
+function shouldRetryPendingSource(stored, mode) {
+    if (!stored?.lastResultPath) {
+        return false;
+    }
+    if (isPendingSyncDataState(stored.dataState)) {
+        return true;
+    }
+    if (mode === "manual") {
+        return (stored.dataState === "ingest_failed" ||
+            stored.ingestScopes?.some((scope) => scope.status === "failed") === true);
+    }
+    return false;
+}
+function buildRetryOptions(stored, mode) {
+    if (!stored) {
+        return undefined;
+    }
+    if (mode !== "manual") {
+        return undefined;
+    }
+    const failedScopes = stored.ingestScopes
+        ?.filter((scope) => scope.status === "failed")
+        .map((scope) => scope.scope) ?? [];
+    return failedScopes.length > 0 ? { scopes: failedScopes } : undefined;
+}
+function mergeIngestScopes(previous, current) {
+    if (!previous && !current) {
+        return undefined;
+    }
+    const merged = new Map();
+    for (const scope of previous ?? []) {
+        merged.set(scope.scope, { ...scope });
+    }
+    const now = new Date().toISOString();
+    for (const scope of current ?? []) {
+        merged.set(scope.scope, {
+            scope: scope.scope,
+            status: scope.status === "stored" ? "stored" : "failed",
+            syncedAt: scope.status === "stored" ? now : merged.get(scope.scope)?.syncedAt,
+            error: scope.status === "failed" ? scope.error : undefined,
+        });
+    }
+    return Array.from(merged.values()).sort((left, right) => left.scope.localeCompare(right.scope));
+}
+function deriveSyncedDataState(scopes, fallback) {
+    if (!scopes || scopes.length === 0) {
+        return fallback ?? "ingest_unavailable";
+    }
+    const storedCount = scopes.filter((scope) => scope.status === "stored").length;
+    const failedCount = scopes.filter((scope) => scope.status === "failed").length;
+    if (storedCount === 0 && failedCount > 0) {
+        return "ingest_failed";
+    }
+    return "ingested_personal_server";
+}
+function summarizeSyncError(scopes) {
+    const failedScopes = scopes?.filter((scope) => scope.status === "failed") ?? [];
+    if (failedScopes.length === 0) {
+        return null;
+    }
+    return failedScopes
+        .map((scope) => `${scope.scope}: ${scope.error ?? "sync failed"}`)
+        .join("; ");
+}
+async function syncPendingSources(target, mode) {
+    const state = await readCliState();
+    const pendingSources = Object.entries(state.sources).filter(([, stored]) => shouldRetryPendingSource(stored, mode));
+    if (pendingSources.length === 0) {
+        return { syncedCount: 0, sourceResults: [] };
+    }
+    let syncedCount = 0;
+    const sourceResults = [];
+    for (const [source, stored] of pendingSources) {
+        if (!stored?.lastResultPath) {
+            continue;
+        }
+        const ingestOptions = buildRetryOptions(stored, mode);
+        const ingestEvents = await ingestResult(source, stored.lastResultPath, target, ingestOptions);
+        const resultEvent = ingestEvents.find((event) => event.type === "ingest-complete" ||
+            event.type === "ingest-partial" ||
+            event.type === "ingest-failed");
+        const mergedScopes = mergeIngestScopes(stored.ingestScopes, resultEvent?.scopeResults);
+        const ingestCompleted = ingestEvents.some((event) => event.type === "ingest-complete");
+        const ingestPartial = ingestEvents.some((event) => event.type === "ingest-partial");
+        if (ingestCompleted || ingestPartial) {
+            syncedCount++;
+            await updateSourceState(source, {
+                dataState: deriveSyncedDataState(mergedScopes, stored.dataState),
+                ingestScopes: mergedScopes,
+                lastError: summarizeSyncError(mergedScopes),
+            });
+        }
+        sourceResults.push({ source, scopeResults: resultEvent?.scopeResults });
+    }
+    return { syncedCount, sourceResults };
+}
+async function runCollectAll(options) {
+    const emit = createEmitter(options);
+    const state = await readCliState();
+    const dueSources = Object.entries(state.sources)
+        .filter(([, stored]) => stored?.connectorInstalled &&
+        isCollectionDue(stored.exportFrequency, stored.lastCollectedAt))
+        .map(([id]) => id);
+    let exitCode = 0;
+    for (const source of dueSources) {
+        const result = await runConnect(source, options);
+        if (result !== 0) {
+            exitCode = result;
+        }
+    }
+    let syncedPendingCount = 0;
+    const target = await detectPersonalServerTarget();
+    if (target.state === "available") {
+        syncedPendingCount = (await syncPendingSources(target, "automatic"))
+            .syncedCount;
+    }
+    if (dueSources.length === 0) {
+        if (syncedPendingCount > 0) {
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify({ message: `Synced ${syncedPendingCount} pending dataset(s).`, count: 0, syncedPendingCount })}\n`);
+            }
+            else {
+                emit.info(`Synced ${syncedPendingCount} pending dataset(s).`);
+            }
+            return 0;
+        }
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({ message: "No sources are due for collection.", count: 0, syncedPendingCount: 0 })}\n`);
+        }
+        else {
+            emit.info("No sources are due for collection.");
+        }
+        return 0;
+    }
+    return exitCode;
+}
+async function runServerSync(options) {
+    const emit = createEmitter(options);
+    const target = await detectPersonalServerTarget();
+    trackActiveTelemetryEvent("server_sync_started");
+    if (target.state !== "available") {
+        trackActiveTelemetryEvent("server_sync_failed", {
+            errorClass: "personal_server_unavailable",
+        });
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({
+                error: "personal_server_unavailable",
+                message: "Personal Server is not available. Run `vana server set-url <url>` to configure.",
+            })}\n`);
+        }
+        else {
+            emit.info("Personal Server is not available. Run `vana server set-url <url>` to configure.");
+        }
+        return 1;
+    }
+    const syncResult = await syncPendingSources(target, "manual");
+    const storedScopeCount = syncResult.sourceResults.reduce((total, entry) => total +
+        (entry.scopeResults?.filter((scopeResult) => scopeResult.status === "stored").length ?? 0), 0);
+    const failedScopeCount = syncResult.sourceResults.reduce((total, entry) => total +
+        (entry.scopeResults?.filter((scopeResult) => scopeResult.status === "failed").length ?? 0), 0);
+    if (syncResult.sourceResults.length === 0) {
+        trackActiveTelemetryEvent("server_sync_completed", {
+            storedScopeCount: 0,
+            failedScopeCount: 0,
+            metadata: { syncedSources: 0 },
+        });
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({ message: "No pending datasets to sync.", syncedCount: 0 })}\n`);
+        }
+        else {
+            emit.info("No pending datasets to sync.");
+        }
+        return 0;
+    }
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({ message: `Synced ${syncResult.syncedCount} dataset(s).`, syncedCount: syncResult.syncedCount })}\n`);
+    }
+    else {
+        // Show per-scope results with scope manifest style
+        const renderer = createHumanRenderer();
+        for (const entry of syncResult.sourceResults) {
+            if (entry.scopeResults && entry.scopeResults.length > 0) {
+                emit.info(`${entry.source}:`);
+                for (const sr of entry.scopeResults) {
+                    if (sr.status === "stored") {
+                        emit.info(`  ${renderer.theme.success("\u2713")} ${sr.scope}`);
+                    }
+                    else {
+                        const errDetail = sr.error ? humanizeIssue(sr.error) : "Failed";
+                        emit.info(`  ${renderer.theme.error("\u2717")} ${sr.scope} ${renderer.theme.muted(`\u2014 ${errDetail}`)}`);
+                    }
+                }
+            }
+        }
+        emit.blank();
+        const allStored = syncResult.sourceResults.every((entry) => !entry.scopeResults ||
+            entry.scopeResults.every((sr) => sr.status === "stored"));
+        emit.success(`Synced ${syncResult.syncedCount} dataset(s).`);
+        emit.blank();
+        if (allStored) {
+            emit.next("vana data list");
+        }
+        else {
+            emit.next("vana server sync");
+        }
+    }
+    trackActiveTelemetryEvent("server_sync_completed", {
+        storedScopeCount,
+        failedScopeCount,
+        metadata: { syncedSources: syncResult.syncedCount },
+    });
+    return 0;
+}
+async function runServerData(scope, options) {
+    const emit = createEmitter(options);
+    const target = await detectPersonalServerTarget();
+    const state = await readCliState();
+    // Gather locally-known scopes from state
+    const localScopes = [];
+    for (const [src, stored] of Object.entries(state.sources)) {
+        if (stored?.ingestScopes) {
+            for (const is of stored.ingestScopes) {
+                localScopes.push({ scope: is.scope, source: src, status: is.status });
+            }
+        }
+    }
+    // If PS is available, try to list remote scopes via client
+    let remoteScopes = [];
+    let didQueryRemoteScopes = false;
+    let remoteScopeFallbackReason;
+    if (target.state === "available" && target.url) {
+        const auth = resolvePersonalServerAuthConfig(target.url);
+        try {
+            if (auth?.type === "bearerToken") {
+                const { createPersonalServerClient: createClient } = await import("../personal-server/client.js");
+                const client = createClient({
+                    url: target.url,
+                    auth,
+                });
+                didQueryRemoteScopes = true;
+                remoteScopes = await client.listScopes(scope);
+            }
+        }
+        catch (err) {
+            remoteScopeFallbackReason =
+                err instanceof Error ? err.message : "unknown error";
+        }
+    }
+    // Use remote scopes if available, otherwise fall back to local
+    const scopeList = didQueryRemoteScopes
+        ? remoteScopes.map((s) => ({
+            scope: s.scope,
+            detail: `${s.count} version${s.count !== 1 ? "s" : ""}`,
+        }))
+        : localScopes
+            .filter((s) => s.status === "stored")
+            .filter((s) => !scope || s.scope.startsWith(scope))
+            .map((s) => ({ scope: s.scope, detail: "1 version" }));
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({
+            count: scopeList.length,
+            scopes: scopeList,
+            source: didQueryRemoteScopes ? "remote" : "local",
+            ...(remoteScopeFallbackReason ? { remoteScopeFallbackReason } : {}),
+        })}\n`);
+        return 0;
+    }
+    if (scopeList.length === 0) {
+        emit.info(didQueryRemoteScopes
+            ? "No data on your Personal Server."
+            : "No scopes found.");
+        if (target.state !== "available") {
+            emit.detail("Personal Server is not available. Showing locally-known scopes only.");
+        }
+        return 0;
+    }
+    for (const entry of scopeList) {
+        emit.keyValue(entry.scope, entry.detail, "muted");
+    }
+    if (!didQueryRemoteScopes && localScopes.length > 0) {
+        emit.blank();
+        emit.detail("Showing locally-known scopes. Connect your Personal Server for live data.");
+    }
+    return 0;
+}
+function getSourceBadge(source) {
+    if (source.dataState === "collected_local" ||
+        source.dataState === "ingested_personal_server" ||
+        source.dataState === "ingest_failed") {
+        return { label: "connected", style: "success" };
+    }
+    if (source.lastRunOutcome === CliOutcomeStatus.NEEDS_INPUT ||
+        source.lastRunOutcome === CliOutcomeStatus.LEGACY_AUTH) {
+        return { label: "needs login", style: "warning" };
+    }
+    if (source.lastRunOutcome === CliOutcomeStatus.RUNTIME_ERROR ||
+        source.lastRunOutcome === CliOutcomeStatus.UNEXPECTED_INTERNAL_ERROR) {
+        return { label: "error", style: "error" };
+    }
+    return { label: "new", style: "muted" };
+}
+function isCollectionDue(frequency, lastCollectedAt) {
+    if (!frequency || !lastCollectedAt) {
+        return true;
+    }
+    const lastMs = new Date(lastCollectedAt).getTime();
+    if (Number.isNaN(lastMs)) {
+        return true;
+    }
+    const now = Date.now();
+    const elapsed = now - lastMs;
+    const intervalMs = parseFrequencyToMs(frequency);
+    return elapsed >= intervalMs;
+}
+function parseFrequencyToMs(frequency) {
+    const lower = frequency.toLowerCase().trim();
+    if (lower === "daily") {
+        return 24 * 60 * 60 * 1000;
+    }
+    if (lower === "weekly") {
+        return 7 * 24 * 60 * 60 * 1000;
+    }
+    if (lower === "monthly") {
+        return 30 * 24 * 60 * 60 * 1000;
+    }
+    const match = /^(\d+)\s*(h|d|m|w)$/i.exec(lower);
+    if (match) {
+        const value = parseInt(match[1], 10);
+        const unit = match[2].toLowerCase();
+        if (unit === "h")
+            return value * 60 * 60 * 1000;
+        if (unit === "d")
+            return value * 24 * 60 * 60 * 1000;
+        if (unit === "w")
+            return value * 7 * 24 * 60 * 60 * 1000;
+        if (unit === "m")
+            return value * 30 * 24 * 60 * 60 * 1000;
+    }
+    // Default to daily if unparseable.
+    return 24 * 60 * 60 * 1000;
+}
+async function renderIconInline(source) {
+    const iconPath = findCachedIconPath(source);
+    if (!iconPath) {
+        return "";
+    }
+    try {
+        // terminal-image is optional — not in package.json dependencies.
+        // The `as string` cast prevents TypeScript from resolving the module at compile time.
+        const terminalImage = (await import("terminal-image"));
+        const imageBuffer = await fsp.readFile(iconPath);
+        return await terminalImage.default.buffer(imageBuffer, {
+            width: 2,
+            height: 1,
+        });
+    }
+    catch {
+        return "";
+    }
+}
+function findCachedIconPath(source) {
+    const cacheDir = getConnectorCacheDir();
+    const extensions = [".png", ".svg", ".jpg", ".jpeg", ".webp"];
+    for (const ext of extensions) {
+        const candidate = path.join(cacheDir, `${source}.icon${ext}`);
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function createEmitter(options) {
+    const renderer = createHumanRenderer();
+    return {
+        event(event) {
+            getActiveTelemetrySession()?.trackCliEvent(event);
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify(event)}\n`);
+            }
+        },
+        info(message) {
+            if (options.json || options.quiet) {
+                return;
+            }
+            process.stdout.write(`${message}\n`);
+        },
+        blank() {
+            if (options.json || options.quiet) {
+                return;
+            }
+            process.stdout.write("\n");
+        },
+        title(message) {
+            if (options.json || options.quiet) {
+                return;
+            }
+            process.stdout.write(`${renderer.title(message)}\n`);
+        },
+        success(message) {
+            if (options.json || options.quiet) {
+                return;
+            }
+            process.stdout.write(`${renderer.success(message)}\n`);
+        },
+        section(message) {
+            if (options.json || options.quiet) {
+                return;
+            }
+            process.stdout.write(`${renderer.section(message)}\n`);
+        },
+        keyValue(label, value, tone = "muted") {
+            if (options.json || options.quiet) {
+                return;
+            }
+            process.stdout.write(`${renderer.keyValue(label, value, tone)}\n`);
+        },
+        detail(message) {
+            if (options.json || options.quiet) {
+                return;
+            }
+            process.stdout.write(`${renderer.detail(message)}\n`);
+        },
+        next(command) {
+            if (options.json || options.quiet) {
+                return;
+            }
+            process.stdout.write(`  ${renderer.theme.muted("Next:")} ${renderer.theme.code(command)}\n`);
+        },
+        bullet(message) {
+            if (options.json || options.quiet) {
+                return;
+            }
+            process.stdout.write(`${renderer.bullet(message)}\n`);
+        },
+        sourceTitle(name, badges = []) {
+            if (options.json || options.quiet) {
+                return;
+            }
+            process.stdout.write(`${renderer.sourceTitle(name, badges.map((badge) => renderer.badge(badge.text, badge.tone)))}\n`);
+        },
+        badge(text, tone = "muted") {
+            return renderer.badge(text, tone);
+        },
+        code(text) {
+            return renderer.theme.code(text);
+        },
+    };
+}
+export function displaySource(source, labels = {}) {
+    return labels[source] ?? source.charAt(0).toUpperCase() + source.slice(1);
+}
+function formatCountLabel(label, count) {
+    const normalizedLabel = label.charAt(0).toUpperCase() + label.slice(1);
+    return `${normalizedLabel} (${count})`;
+}
+function joinOverviewParts(parts) {
+    return parts.filter(Boolean).join(" · ");
+}
+function humanizeField(value) {
+    return value
+        .replace(/([a-z])([A-Z])/g, "$1 $2")
+        .replace(/[_-]/g, " ")
+        .replace(/^\w/, (match) => match.toUpperCase());
+}
+export function humanizeIssue(message) {
+    if (/checksum|mismatch/i.test(message)) {
+        return "Connector is out of date. Will auto-update on next connect.";
+    }
+    const transportSummary = summarizeTransportError(message);
+    if (transportSummary) {
+        return transportSummary;
+    }
+    return message;
+}
+function summarizeTransportError(message) {
+    const httpMatch = message.match(/^HTTP\s+\d+:\s*(.+)$/s);
+    if (!httpMatch) {
+        return null;
+    }
+    const payload = httpMatch[1].trim();
+    const parsed = parseTransportErrorPayload(payload);
+    if (parsed) {
+        return parsed.message;
+    }
+    const messageMatch = payload.match(/"message"\s*:\s*"([^"]+)"/);
+    if (messageMatch) {
+        return messageMatch[1];
+    }
+    return "Request failed";
+}
+function parseTransportErrorPayload(payload) {
+    try {
+        const parsed = JSON.parse(payload);
+        const rawError = typeof parsed.error === "string"
+            ? parsed.error
+            : parsed.error && typeof parsed.error === "object"
+                ? (parsed.error.errorCode ??
+                    parsed.error.code)
+                : undefined;
+        const rawMessage = typeof parsed.message === "string"
+            ? parsed.message
+            : parsed.error && typeof parsed.error === "object"
+                ? parsed.error.message
+                : undefined;
+        const code = typeof rawError === "string" || typeof rawError === "number"
+            ? String(rawError)
+            : undefined;
+        const message = typeof rawMessage === "string" ? rawMessage : "Request failed";
+        return { code, message: summarizeTransportCode(code, message) };
+    }
+    catch {
+        return null;
+    }
+}
+function summarizeTransportCode(code, message) {
+    if (code === "MISSING_AUTH" || /missing authentication/i.test(message)) {
+        return "Authentication required";
+    }
+    if (code === "NO_SCHEMA" || /no schema registered/i.test(message)) {
+        return "No schema registered";
+    }
+    if (code === "INVALID_SCOPE" || /scope must be/i.test(message)) {
+        return "Unsupported scope";
+    }
+    return message;
+}
+function formatHumanSourceMessage(message, source, displayName) {
+    if (!message || source === displayName) {
+        return message;
+    }
+    return message.replace(new RegExp(`\\b${escapeRegExp(source)}\\b`, "gi"), displayName);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function getErrorLogPath(error) {
+    if (error &&
+        typeof error === "object" &&
+        "logPath" in error &&
+        typeof error.logPath === "string") {
+        return error.logPath;
+    }
+    return null;
+}
+export async function gatherSourceStatuses(storedSources, metadata = {}) {
+    const installedFiles = await listInstalledConnectorFiles();
+    const sourceNames = new Set([
+        ...Object.keys(storedSources),
+        ...installedFiles.map((file) => file.source),
+    ]);
+    return [...sourceNames]
+        .map((source) => {
+        const stored = storedSources[source] ?? {};
+        const installed = installedFiles.some((file) => file.source === source);
+        const details = metadata[source];
+        const dataState = stored.dataState === "ingested_personal_server"
+            ? "ingested_personal_server"
+            : stored.dataState === "ingest_unavailable"
+                ? "ingest_unavailable"
+                : stored.dataState === "ingest_failed"
+                    ? "ingest_failed"
+                    : stored.dataState === "collected_local"
+                        ? "collected_local"
+                        : "none";
+        const ingestScopes = stored.ingestScopes;
+        const syncedScopeCount = ingestScopes?.filter((s) => s.status === "stored").length ?? 0;
+        const failedScopeCount = ingestScopes?.filter((s) => s.status === "failed").length ?? 0;
+        const isOverdue = stored.lastCollectedAt && stored.exportFrequency
+            ? isCollectionDue(stored.exportFrequency, stored.lastCollectedAt)
+            : undefined;
+        const suggestedNextCollectionAt = stored.lastCollectedAt && stored.exportFrequency
+            ? new Date(new Date(stored.lastCollectedAt).getTime() +
+                parseFrequencyToMs(stored.exportFrequency)).toISOString()
+            : undefined;
+        return {
+            source,
+            name: details?.name,
+            company: details?.company,
+            description: details?.description,
+            authMode: details?.authMode ?? inferInstalledAuthMode(installedFiles, source),
+            connectorVersion: stored.connectorVersion,
+            exportFrequency: stored.exportFrequency,
+            lastCollectedAt: stored.lastCollectedAt,
+            connectionHealth: stored.connectionHealth,
+            connectionHealthChangedAt: stored.connectionHealthChangedAt,
+            connectionHealthReason: stored.connectionHealthReason,
+            connectionHealthRetryable: stored.connectionHealthRetryable,
+            installed,
+            sessionPresent: stored.sessionPresent ?? false,
+            lastRunAt: stored.lastRunAt ?? null,
+            lastRunOutcome: stored.lastRunOutcome ?? null,
+            dataState,
+            lastError: stored.lastError ?? null,
+            lastResultPath: stored.lastResultPath ?? null,
+            lastLogPath: stored.lastLogPath ?? null,
+            ingestScopes,
+            syncedScopeCount: syncedScopeCount > 0 ? syncedScopeCount : undefined,
+            failedScopeCount: failedScopeCount > 0 ? failedScopeCount : undefined,
+            suggestedNextCollectionAt,
+            isOverdue,
+        };
+    })
+        .sort(compareSourceStatusOrder);
+}
+export async function listInstalledConnectorFiles() {
+    const connectorsDir = getConnectorCacheDir();
+    try {
+        const results = [];
+        const entries = await fsp.readdir(connectorsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            const companyDir = path.join(connectorsDir, entry.name);
+            const files = await fsp.readdir(companyDir);
+            for (const file of files) {
+                if (!file.endsWith("-playwright.js")) {
+                    continue;
+                }
+                results.push({
+                    source: file.replace(/-playwright\.js$/, ""),
+                    path: path.join(companyDir, file),
+                });
+            }
+        }
+        return results;
+    }
+    catch {
+        return [];
+    }
+}
+function formatSourceStatusDetails(source) {
+    const details = [];
+    const displayName = source.name ?? displaySource(source.source);
+    if (source.lastRunOutcome === CliOutcomeStatus.NEEDS_INPUT) {
+        details.push(source.lastError
+            ? {
+                kind: "text",
+                message: `${source.lastError}. Run \`vana connect ${source.source}\` interactively.`,
+            }
+            : {
+                kind: "text",
+                message: `Run \`vana connect ${source.source}\` interactively.`,
+            });
+    }
+    if (source.lastRunOutcome === CliOutcomeStatus.LEGACY_AUTH) {
+        details.push({
+            kind: "text",
+            message: `Run \`vana connect ${source.source}\` without \`--no-input\` to complete the manual browser step.`,
+        });
+    }
+    if (source.lastRunOutcome === CliOutcomeStatus.RUNTIME_ERROR) {
+        details.push(source.lastError
+            ? {
+                kind: "text",
+                message: formatHumanSourceMessage(source.lastError, source.source, displayName),
+            }
+            : {
+                kind: "text",
+                message: "The last connector run failed.",
+            });
+    }
+    if (source.lastRunOutcome === CliOutcomeStatus.CONNECTOR_UNAVAILABLE) {
+        details.push(source.lastError
+            ? {
+                kind: "text",
+                message: formatHumanSourceMessage(source.lastError, source.source, displayName),
+            }
+            : {
+                kind: "text",
+                message: "No connector is available for this source.",
+            });
+    }
+    if (!source.lastRunOutcome && source.installed) {
+        details.push({
+            kind: "text",
+            message: `Run \`vana connect ${source.source}\` to collect data.`,
+        });
+    }
+    if (source.lastRunOutcome === CliOutcomeStatus.CONNECTED_LOCAL_ONLY &&
+        source.lastResultPath) {
+        details.push({
+            kind: "text",
+            message: `Inspect the latest local dataset with \`vana data show ${source.source}\`.`,
+        });
+    }
+    if (source.sessionPresent &&
+        (source.lastRunOutcome === CliOutcomeStatus.CONNECTED_LOCAL_ONLY ||
+            source.lastRunOutcome === CliOutcomeStatus.CONNECTED_AND_INGESTED ||
+            source.lastRunOutcome === CliOutcomeStatus.INGEST_FAILED)) {
+        details.push({
+            kind: "row",
+            label: "Session",
+            value: "Session cached.",
+            tone: "muted",
+        });
+    }
+    if (source.lastRunOutcome === CliOutcomeStatus.CONNECTED_AND_INGESTED) {
+        details.push({
+            kind: "text",
+            message: `Inspect the latest local dataset with \`vana data show ${source.source}\` or use your Personal Server copy.`,
+        });
+    }
+    if (source.lastRunOutcome === CliOutcomeStatus.INGEST_FAILED) {
+        details.push(source.lastError
+            ? {
+                kind: "text",
+                message: `${source.lastError} Inspect the local dataset with \`vana data show ${source.source}\`.`,
+            }
+            : {
+                kind: "text",
+                message: `Personal Server sync failed. Inspect the local dataset with \`vana data show ${source.source}\`.`,
+            });
+    }
+    if (source.dataState === "ingested_personal_server") {
+        details.push({
+            kind: "row",
+            label: "State",
+            value: "Synced to Personal Server",
+            tone: "success",
+        });
+    }
+    else if (source.dataState === "ingest_unavailable") {
+        details.push({
+            kind: "row",
+            label: "State",
+            value: "Pending sync to Personal Server",
+            tone: "warning",
+        });
+    }
+    else if (source.dataState === "ingest_failed") {
+        details.push({
+            kind: "row",
+            label: "State",
+            value: "Saved locally, sync failed",
+            tone: "warning",
+        });
+    }
+    else if (source.dataState === "collected_local") {
+        details.push({
+            kind: "row",
+            label: "State",
+            value: "Saved locally",
+            tone: "muted",
+        });
+    }
+    if (source.connectionHealthReason && source.connectionHealth !== "healthy") {
+        details.push({
+            kind: "row",
+            label: "Cause",
+            value: source.connectionHealthReason,
+            tone: "muted",
+        });
+    }
+    if (source.lastRunAt) {
+        details.push({
+            kind: "row",
+            label: "Updated",
+            value: `${formatTimestamp(source.lastRunAt)} (${formatRelativeTime(source.lastRunAt)})`,
+            tone: "muted",
+        });
+    }
+    if (source.lastResultPath && source.dataState !== "none") {
+        details.push({
+            kind: "row",
+            label: "Path",
+            value: formatDisplayPath(source.lastResultPath),
+            tone: "muted",
+        });
+    }
+    if (source.lastLogPath &&
+        source.lastRunOutcome &&
+        source.lastRunOutcome !== CliOutcomeStatus.CONNECTED_LOCAL_ONLY &&
+        source.lastRunOutcome !== CliOutcomeStatus.CONNECTED_AND_INGESTED) {
+        details.push({
+            kind: "row",
+            label: "Run log",
+            value: formatDisplayPath(source.lastLogPath),
+            tone: "muted",
+        });
+    }
+    return details;
+}
+export function buildStatusNextSteps(sources, sourceLabels = {}, runtime = "unhealthy", availableSources = []) {
+    const nextSteps = [];
+    const attentionSources = [...sources]
+        .filter(isSourceAttention)
+        .sort(compareAttentionPriority);
+    const highestPriority = attentionSources[0] ?? [...sources].sort(compareSourceStatusOrder)[0];
+    const connectedSources = sources.filter((source) => source.dataState === "collected_local" ||
+        source.dataState === "ingested_personal_server" ||
+        source.dataState === "ingest_failed" ||
+        source.dataState === "ingest_unavailable");
+    const needsAttention = attentionSources.length > 0;
+    const highestPriorityLabel = highestPriority
+        ? displaySource(highestPriority.source, sourceLabels)
+        : null;
+    const suggestedSource = availableSources.find((source) => source.authMode !== "legacy") ??
+        availableSources[0];
+    if (!highestPriority) {
+        if (runtime === "installed") {
+            if (suggestedSource) {
+                nextSteps.push(`Connect ${suggestedSource.name} with \`vana connect ${suggestedSource.id}\`.`);
+            }
+            else {
+                nextSteps.push("Connect your first source with `vana connect`.");
+            }
+        }
+        else if (runtime === "missing") {
+            nextSteps.push("Install the local runtime with `vana setup`.");
+            nextSteps.push("Inspect install health with `vana doctor`.");
+        }
+        else if (runtime === "unhealthy") {
+            nextSteps.push("Inspect install health with `vana doctor`.");
+        }
+    }
+    else if (highestPriority.dataState === "ingest_failed") {
+        nextSteps.push(`Reconnect ${highestPriorityLabel} with \`vana connect ${highestPriority.source}\`.`);
+    }
+    else if (highestPriority.dataState === "ingest_unavailable") {
+        nextSteps.push("Retry pending Personal Server sync with `vana server sync`.");
+    }
+    else if (highestPriority.connectionHealth === "needs_reauth" ||
+        highestPriority.lastRunOutcome === CliOutcomeStatus.NEEDS_INPUT) {
+        nextSteps.push(`Reconnect ${highestPriorityLabel} with \`vana connect ${highestPriority.source}\`.`);
+        if (highestPriority.lastLogPath) {
+            nextSteps.push(`Inspect the latest run log with \`vana logs ${highestPriority.source}\`.`);
+        }
+    }
+    else if (highestPriority.connectionHealth === "error" ||
+        highestPriority.lastRunOutcome === CliOutcomeStatus.RUNTIME_ERROR) {
+        nextSteps.push(`Retry ${highestPriorityLabel} with \`vana connect ${highestPriority.source}\`.`);
+        if (highestPriority.lastLogPath) {
+            nextSteps.push(`Inspect the latest run log with \`vana logs ${highestPriority.source}\`.`);
+        }
+    }
+    else if (highestPriority.lastRunOutcome === CliOutcomeStatus.LEGACY_AUTH) {
+        nextSteps.push(`Complete the manual browser step for ${highestPriorityLabel} with \`vana connect ${highestPriority.source}\`.`);
+        if (highestPriority.lastLogPath) {
+            nextSteps.push(`Inspect the latest run log with \`vana logs ${highestPriority.source}\`.`);
+        }
+    }
+    else if (highestPriority.lastRunOutcome === CliOutcomeStatus.CONNECTOR_UNAVAILABLE) {
+        nextSteps.push("Browse available sources with `vana sources`.");
+        if (highestPriority.lastLogPath) {
+            nextSteps.push(`Inspect the latest run log with \`vana logs ${highestPriority.source}\`.`);
+        }
+    }
+    else if (highestPriority.dataState === "collected_local" ||
+        highestPriority.dataState === "ingested_personal_server") {
+        if (connectedSources.length > 1) {
+            nextSteps.push("Review your collected data with `vana data list`.");
+        }
+        else {
+            nextSteps.push(`Inspect the latest dataset with \`vana data show ${highestPriority.source}\`.`);
+        }
+    }
+    if (connectedSources.length > 0 && needsAttention) {
+        nextSteps.push(connectedSources.length > 1
+            ? "Review the data you already collected with `vana data list`."
+            : `Inspect the data you already collected with \`vana data show ${connectedSources[0].source}\`.`);
+    }
+    if (sources.some((source) => source.installed || source.lastRunOutcome) &&
+        (!needsAttention || connectedSources.length === 0)) {
+        nextSteps.push("Connect another source with `vana sources`.");
+    }
+    if (runtime !== "installed" ||
+        sources.some((source) => source.lastRunOutcome === CliOutcomeStatus.RUNTIME_ERROR ||
+            source.lastRunOutcome === CliOutcomeStatus.UNEXPECTED_INTERNAL_ERROR)) {
+        nextSteps.push("Inspect install health with `vana doctor`.");
+    }
+    return [...new Set(nextSteps)];
+}
+export function buildSourcesNextSteps(recommendedSource, connectedCount) {
+    const nextSteps = [];
+    if (connectedCount > 0) {
+        nextSteps.push("Inspect what you already collected with `vana data list`.");
+    }
+    if (recommendedSource) {
+        nextSteps.push(`${recommendedSource.authMode === "legacy" ? "Complete" : "Connect"} ${recommendedSource.name} with \`vana connect ${recommendedSource.id}\`.`);
+    }
+    nextSteps.push("Or browse the guided picker with `vana connect`.");
+    return [...new Set(nextSteps)];
+}
+export function buildDataListNextSteps(datasetRecords, registrySources) {
+    if (datasetRecords.length === 0) {
+        const suggestedSource = registrySources.find((source) => source.authMode !== "legacy") ??
+            registrySources[0];
+        return [
+            suggestedSource
+                ? `Collect your first dataset with \`vana connect ${suggestedSource.id}\`.`
+                : "Collect your first dataset with `vana connect`.",
+            "Check overall status with `vana status`.",
+        ];
+    }
+    return [
+        `Inspect ${datasetRecords[0].name ?? displaySource(datasetRecords[0].source)} with \`vana data show ${datasetRecords[0].source}\`.`,
+        `Or print its path with \`vana data path ${datasetRecords[0].source}\`.`,
+        "Connect another source with `vana sources`.",
+    ];
+}
+export function buildDataShowNextSteps(source, datasetCount, sourceLabels = {}) {
+    return [
+        `Print the path with \`vana data path ${source}\`.`,
+        `Reconnect ${displaySource(source, sourceLabels)} with \`vana connect ${source}\`.`,
+        ...(datasetCount > 1
+            ? ["See all datasets with `vana data list`."]
+            : ["Connect another source with `vana sources`."]),
+    ];
+}
+function buildLogsNextSteps(records) {
+    if (records.length === 0) {
+        return [
+            "Run `vana connect <source>` to create a connector run log.",
+            "Check overall status with `vana status`.",
+        ];
+    }
+    const attentionRecord = records.find((record) => isAttentionLog(record.lastRunOutcome, record.dataState));
+    const successfulRecord = records.find((record) => !isAttentionLog(record.lastRunOutcome, record.dataState));
+    return [
+        attentionRecord
+            ? `Inspect the latest issue log with \`vana logs ${attentionRecord.source}\`.`
+            : `Print the latest log path with \`vana logs ${records[0].source}\`.`,
+        ...(successfulRecord
+            ? [
+                `Inspect a successful run with \`vana logs ${successfulRecord.source}\`.`,
+            ]
+            : []),
+        "Check overall status with `vana status`.",
+    ];
+}
+/** Derive a human-readable message from a stored `connectionHealthReason`. */
+export function formatHealthMessage(reason) {
+    if (!reason)
+        return null;
+    const colonIndex = reason.indexOf(": ");
+    const prefix = colonIndex > 0 ? reason.slice(0, colonIndex) : reason;
+    const detail = colonIndex > 0 ? reason.slice(colonIndex + 2).replace(/\.$/, "") : "";
+    switch (prefix) {
+        case "needs-input":
+            return `Requires interactive login${detail ? `: ${detail}` : ""}.`;
+        case "legacy-auth":
+            return `Needed a browser window${detail ? `: ${detail}` : ""}. Reconnect interactively.`;
+        case "runtime-error":
+            return `Collection failed${detail ? ` — ${detail}` : ""}.`;
+        case "error-result":
+            return `Connector returned an error${detail ? `: ${detail}` : ""}.`;
+        case "collection-complete":
+            return null; // No message needed for healthy state
+        default:
+            return reason; // Graceful fallback for unknown prefixes
+    }
+}
+/** Extract a `vana ...` command from a next-step sentence wrapped in backticks. */
+function extractCommand(sentence) {
+    const match = sentence.match(/`(vana\s[^`]+)`/);
+    return match ? match[1] : null;
+}
+// describeConnectTrust and buildConnectChoices removed — replaced by clack-based picker
+function formatMissingConnectSourceMessage(source) {
+    if (source) {
+        return `Specify a source. Start with \`vana connect ${source.id}\`, or run \`vana sources\` to see available options.`;
+    }
+    return "Specify a source. Run `vana sources` to see available options.";
+}
+// formatSourcePickerDescription removed — replaced by clack-based picker with hints
+function normalizeArgv(argv) {
+    if (argv[2] === "connect" &&
+        ["list", "status", "setup"].includes(argv[3] ?? "")) {
+        const mapping = {
+            list: "sources",
+            status: "status",
+            setup: "setup",
+        };
+        return [argv[0], argv[1], mapping[argv[3]], ...argv.slice(4)];
+    }
+    return argv;
+}
+export function getCliVersion() {
+    if (process.env.VANA_APP_ROOT) {
+        try {
+            const packageJson = JSON.parse(fs.readFileSync(path.join(process.env.VANA_APP_ROOT, "package.json"), "utf8"));
+            if (packageJson.version) {
+                return packageJson.version;
+            }
+        }
+        catch {
+            // Fall through to the repo/dev package metadata.
+        }
+    }
+    try {
+        const packageJson = require("../../package.json");
+        if (packageJson.version) {
+            return packageJson.version;
+        }
+    }
+    catch {
+        // Fall through to the hard default.
+    }
+    return "0.0.0";
+}
+export function getCliChannel(version = getCliVersion()) {
+    if (version.includes("canary")) {
+        return "canary";
+    }
+    const candidates = [process.env.VANA_APP_ROOT ?? "", process.execPath].map((value) => value.replace(/\\/g, "/").toLowerCase());
+    return candidates.some((normalizedPath) => /\/releases\/canary-[^/]+(?:\/app)?$/.test(normalizedPath))
+        ? "canary"
+        : "stable";
+}
+export function getCliInstallMethod(execPath = process.execPath) {
+    const candidates = [process.env.VANA_APP_ROOT ?? "", execPath].map((value) => value.replace(/\\/g, "/").toLowerCase());
+    for (const normalizedPath of candidates) {
+        if (!normalizedPath) {
+            continue;
+        }
+        if (normalizedPath.includes("/cellar/vana/")) {
+            return "homebrew";
+        }
+        if (normalizedPath.includes("/.local/share/vana/") ||
+            normalizedPath.includes("/appdata/local/vana/") ||
+            normalizedPath.endsWith("/current/app") ||
+            /\/releases\/[^/]+\/app$/.test(normalizedPath)) {
+            return "installer";
+        }
+        if (normalizedPath.endsWith("/node") ||
+            normalizedPath.endsWith("/node.exe") ||
+            normalizedPath.includes("/.nvm/") ||
+            normalizedPath.includes("/volta/") ||
+            normalizedPath.includes("/pnpm/")) {
+            return "development";
+        }
+    }
+    return "unknown";
+}
+function getCliAppRoot(execPath = process.execPath) {
+    return process.env.VANA_APP_ROOT ?? path.join(path.dirname(execPath), "app");
+}
+export function getDoctorAppRootPath(installMethod, execPath = process.execPath) {
+    if (process.env.VANA_APP_ROOT) {
+        return process.env.VANA_APP_ROOT;
+    }
+    if (installMethod === "homebrew" || installMethod === "installer") {
+        return getCliAppRoot(execPath);
+    }
+    return null;
+}
+export function formatInstallMethodLabel(method) {
+    switch (method) {
+        case "homebrew":
+            return "Homebrew";
+        case "installer":
+            return "Hosted installer";
+        case "development":
+            return "Development checkout";
+        default:
+            return "Unknown";
+    }
+}
+export function getLifecycleCommands(installMethod, channel) {
+    switch (installMethod) {
+        case "homebrew":
+            return {
+                upgrade: "brew update && brew upgrade vana",
+                uninstall: "brew uninstall vana",
+            };
+        case "installer":
+            if (process.platform === "win32") {
+                return {
+                    upgrade: 'powershell -Command "irm https://raw.githubusercontent.com/vana-com/vana-cli/main/install/install.ps1 | iex"',
+                    uninstall: 'powershell -Command "Remove-Item $env:LOCALAPPDATA\\Vana -Recurse -Force; Remove-Item $env:USERPROFILE\\.vana -Recurse -Force"',
+                };
+            }
+            return {
+                upgrade: channel === "canary"
+                    ? "curl -fsSL https://raw.githubusercontent.com/vana-com/vana-cli/feat/connect-cli-v1/install/install.sh | sh -s -- --version canary-feat-connect-cli-v1"
+                    : "curl -fsSL https://raw.githubusercontent.com/vana-com/vana-cli/main/install/install.sh | sh",
+                uninstall: "rm -f ~/.local/bin/vana && rm -rf ~/.local/share/vana ~/.vana",
+            };
+        case "development":
+            return {
+                upgrade: "git pull && pnpm install && pnpm build",
+                uninstall: "Remove the local checkout and any generated ~/.vana state.",
+            };
+        default:
+            return {
+                upgrade: "Reinstall vana using Homebrew or the hosted installer.",
+                uninstall: "Remove the installed vana binary and any ~/.vana state you no longer need.",
+            };
+    }
+}
+function extractGlobalOptions(argv) {
+    return {
+        json: argv.includes("--json"),
+        noInput: argv.includes("--no-input"),
+        ipc: argv.includes("--ipc"),
+        yes: argv.includes("--yes"),
+        quiet: argv.includes("--quiet"),
+        detach: argv.includes("--detach"),
+    };
+}
+export function createSourceLabelMap(sources) {
+    return Object.fromEntries(sources.map((source) => [source.id, source.name]));
+}
+export function createSourceMetadataMap(sources) {
+    return Object.fromEntries(sources.map((source) => [
+        source.id,
+        {
+            name: source.name,
+            company: source.company,
+            description: source.description,
+            authMode: source.authMode,
+        },
+    ]));
+}
+// formatAuthModeBadge removed — replaced by clack-based picker with hints
+export function getSourceStatusPresentation(source) {
+    if (!source.installed && !source.lastRunOutcome) {
+        return { label: "not connected", tone: "muted" };
+    }
+    // Check dataState before early-returning on missing lastRunOutcome —
+    // ingest can fail even when lastRunOutcome is unset
+    if (source.dataState === "ingest_failed") {
+        return { label: "sync failed", tone: "error" };
+    }
+    if (!source.lastRunOutcome) {
+        return { label: "installed", tone: "success" };
+    }
+    if (source.lastRunOutcome === CliOutcomeStatus.NEEDS_INPUT) {
+        return { label: "needs input", tone: "warning" };
+    }
+    if (source.lastRunOutcome === CliOutcomeStatus.RUNTIME_ERROR) {
+        return { label: "error", tone: "error" };
+    }
+    if (source.lastRunOutcome === CliOutcomeStatus.CONNECTOR_UNAVAILABLE) {
+        return { label: "unavailable", tone: "warning" };
+    }
+    if (source.lastRunOutcome === CliOutcomeStatus.LEGACY_AUTH) {
+        return { label: "manual step", tone: "warning" };
+    }
+    if (source.dataState === "ingested_personal_server") {
+        // Check per-scope state for more granular badges
+        if (source.ingestScopes && source.ingestScopes.length > 0) {
+            const storedCount = source.ingestScopes.filter((s) => s.status === "stored").length;
+            const failedCount = source.ingestScopes.filter((s) => s.status === "failed").length;
+            if (failedCount > 0 && storedCount > 0) {
+                return { label: "partial sync", tone: "warning" };
+            }
+            if (failedCount > 0 && storedCount === 0) {
+                return { label: "sync failed", tone: "error" };
+            }
+        }
+        return { label: "synced", tone: "success" };
+    }
+    if (source.dataState === "ingest_unavailable") {
+        return { label: "pending sync", tone: "warning" };
+    }
+    if (source.dataState === "collected_local") {
+        return { label: "local", tone: "muted" };
+    }
+    return { label: "connected", tone: "success" };
+}
+export function toneForRuntime(runtime) {
+    if (runtime === "installed") {
+        return "success";
+    }
+    if (runtime === "missing") {
+        return "warning";
+    }
+    return "muted";
+}
+// formatProgressUpdate removed — replaced by ConnectRenderer scope methods
+/**
+ * Extract a human-readable scope name from a progress-update event.
+ * The scope name comes from `phase.label` when `phase` is a structured object.
+ */
+function extractScopeName(event) {
+    if (event.phase &&
+        typeof event.phase === "object" &&
+        "label" in event.phase &&
+        typeof event.phase.label === "string") {
+        return event.phase.label;
+    }
+    return null;
+}
+/**
+ * Format detail text for a completed scope (e.g. "8 found").
+ * Extracts count from event.count or parses it from the message.
+ */
+function formatScopeDetail(event) {
+    if (typeof event.count === "number") {
+        return `${event.count} found`;
+    }
+    // Try to extract a count from the completion message (e.g. "Complete! 8 repositories collected.")
+    if (typeof event.message === "string") {
+        const match = event.message.match(/(\d+)\s+\w+/);
+        if (match) {
+            return match[0];
+        }
+    }
+    return undefined;
+}
+// shouldRenderStatusUpdate removed — status updates are silent in the new design
+function inferInstalledAuthMode(installedFiles, source) {
+    const match = installedFiles.find((file) => file.source === source);
+    if (!match) {
+        return undefined;
+    }
+    try {
+        const script = fs.readFileSync(match.path, "utf8");
+        if (/page\.requestInput\(/.test(script)) {
+            return "interactive";
+        }
+        if (/page\.(showBrowser|promptUser)\(/.test(script)) {
+            return "legacy";
+        }
+        return "automated";
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function loadRegistrySources() {
+    try {
+        return ((await listAvailableSources(findDataConnectorsDir() ?? undefined)) ?? []).sort(compareRegistrySourceOrder);
+    }
+    catch {
+        return [];
+    }
+}
+function compareRegistrySourceOrder(left, right) {
+    return (rankAuthMode(left.authMode) - rankAuthMode(right.authMode) ||
+        left.name.localeCompare(right.name, undefined, { sensitivity: "base" }));
+}
+export function compareSourceStatusOrder(left, right) {
+    return (rankSourceStatus(left) - rankSourceStatus(right) ||
+        compareRegistrySourceOrder({
+            id: left.source,
+            name: left.name ?? displaySource(left.source),
+            authMode: left.authMode,
+        }, {
+            id: right.source,
+            name: right.name ?? displaySource(right.source),
+            authMode: right.authMode,
+        }));
+}
+export function isSourceAttention(source) {
+    if (source.dataState === "ingest_failed" ||
+        source.dataState === "ingest_unavailable") {
+        return true;
+    }
+    if (source.connectionHealth === "needs_reauth" ||
+        source.connectionHealth === "error" ||
+        source.connectionHealth === "stale") {
+        return true;
+    }
+    return rankSourceStatus(source) <= 4;
+}
+function compareAttentionPriority(left, right) {
+    const rank = (source) => {
+        if (source.dataState === "ingest_failed") {
+            return 0;
+        }
+        if (source.dataState === "ingest_unavailable") {
+            return 1;
+        }
+        if (source.connectionHealth === "needs_reauth") {
+            return 2;
+        }
+        if (source.connectionHealth === "error") {
+            return 3;
+        }
+        if (source.lastRunOutcome === CliOutcomeStatus.RUNTIME_ERROR) {
+            return 4;
+        }
+        if (source.lastRunOutcome === CliOutcomeStatus.NEEDS_INPUT) {
+            return 5;
+        }
+        if (source.lastRunOutcome === CliOutcomeStatus.LEGACY_AUTH) {
+            return 6;
+        }
+        if (source.lastRunOutcome === CliOutcomeStatus.CONNECTOR_UNAVAILABLE) {
+            return 7;
+        }
+        return 8;
+    };
+    return rank(left) - rank(right) || compareSourceStatusOrder(left, right);
+}
+export function rankSourceStatus(source) {
+    if (source.lastRunOutcome === CliOutcomeStatus.NEEDS_INPUT) {
+        return 0;
+    }
+    if (source.lastRunOutcome === CliOutcomeStatus.LEGACY_AUTH) {
+        return 1;
+    }
+    if (source.lastRunOutcome === CliOutcomeStatus.INGEST_FAILED) {
+        return 2;
+    }
+    if (source.lastRunOutcome === CliOutcomeStatus.RUNTIME_ERROR) {
+        return 3;
+    }
+    if (source.lastRunOutcome === CliOutcomeStatus.CONNECTOR_UNAVAILABLE) {
+        return 4;
+    }
+    if (source.dataState === "ingest_failed") {
+        return 2;
+    }
+    if (source.dataState === "ingested_personal_server") {
+        return 5;
+    }
+    if (source.dataState === "collected_local") {
+        return 6;
+    }
+    if (source.installed) {
+        return 7;
+    }
+    return 8;
+}
+function rankAuthMode(authMode) {
+    if (authMode === "interactive") {
+        return 0;
+    }
+    if (authMode === "automated") {
+        return 1;
+    }
+    if (authMode === "legacy") {
+        return 2;
+    }
+    return 3;
+}
+export async function readResultSummary(resultPath) {
+    try {
+        const raw = await fsp.readFile(resultPath, "utf8");
+        return summarizeResultData(JSON.parse(raw));
+    }
+    catch {
+        return null;
+    }
+}
+export function summarizeResultData(data) {
+    const lines = [];
+    const exportSummary = typeof data.exportSummary === "object" && data.exportSummary
+        ? data.exportSummary
+        : null;
+    const profile = typeof data.profile === "object" && data.profile
+        ? data.profile
+        : null;
+    if (profile?.username && typeof profile.username === "string") {
+        lines.push(`Profile: ${profile.username}`);
+    }
+    if (Array.isArray(data.repositories)) {
+        lines.push(`Repositories: ${data.repositories.length}`);
+        const preview = summarizeNamedItems(data.repositories, "Latest repos");
+        if (preview) {
+            lines.push(preview);
+        }
+    }
+    if (Array.isArray(data.starred)) {
+        lines.push(`Starred: ${data.starred.length}`);
+    }
+    if (Array.isArray(data.orders)) {
+        lines.push(`Orders: ${data.orders.length}`);
+    }
+    if (Array.isArray(data.playlists)) {
+        lines.push(`Playlists: ${data.playlists.length}`);
+        const preview = summarizeNamedItems(data.playlists, "Playlists");
+        if (preview) {
+            lines.push(preview);
+        }
+    }
+    if (exportSummary?.details &&
+        typeof exportSummary.details === "string" &&
+        !lines.includes(exportSummary.details) &&
+        !Array.isArray(data.repositories) &&
+        !Array.isArray(data.starred) &&
+        !Array.isArray(data.orders) &&
+        !Array.isArray(data.playlists)) {
+        lines.push(exportSummary.details);
+    }
+    return lines.length > 0 ? { lines } : null;
+}
+function summarizeNamedItems(items, label, maxItems = 2) {
+    const names = items
+        .map((item) => {
+        if (typeof item === "object" &&
+            item &&
+            "name" in item &&
+            typeof item.name === "string") {
+            return item.name;
+        }
+        return null;
+    })
+        .filter((value) => Boolean(value))
+        .slice(0, maxItems);
+    if (names.length === 0) {
+        return null;
+    }
+    return `${label}: ${names.join(", ")}`;
+}
+export function formatTimestamp(value) {
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime())) {
+        return value;
+    }
+    return new Intl.DateTimeFormat(undefined, {
+        dateStyle: "medium",
+        timeStyle: "short",
+    }).format(date);
+}
+export function compareDatasetOrder(left, right) {
+    const leftTime = left.lastRunAt ? Date.parse(left.lastRunAt) : 0;
+    const rightTime = right.lastRunAt ? Date.parse(right.lastRunAt) : 0;
+    return (rightTime - leftTime ||
+        (left.name ?? left.source).localeCompare(right.name ?? right.source, undefined, {
+            sensitivity: "base",
+        }));
+}
+function compareLogRecordOrder(left, right) {
+    const leftTimestamp = left.lastRunAt ? Date.parse(left.lastRunAt) : 0;
+    const rightTimestamp = right.lastRunAt ? Date.parse(right.lastRunAt) : 0;
+    return (rightTimestamp - leftTimestamp ||
+        left.source.localeCompare(right.source, undefined, {
+            sensitivity: "base",
+        }));
+}
+export function hasCollectedData(dataState) {
+    return (dataState === "collected_local" ||
+        dataState === "ingest_unavailable" ||
+        dataState === "ingested_personal_server" ||
+        dataState === "ingest_failed");
+}
+function formatLogOutcomeLabel(lastRunOutcome, dataState) {
+    if (lastRunOutcome === CliOutcomeStatus.CONNECTOR_UNAVAILABLE) {
+        return "unavailable";
+    }
+    if (lastRunOutcome === CliOutcomeStatus.LEGACY_AUTH) {
+        return "manual step";
+    }
+    if (lastRunOutcome === CliOutcomeStatus.RUNTIME_ERROR) {
+        return "error";
+    }
+    if (lastRunOutcome === CliOutcomeStatus.NEEDS_INPUT) {
+        return "needs input";
+    }
+    if (dataState === "ingested_personal_server") {
+        return "synced";
+    }
+    if (dataState === "ingest_unavailable") {
+        return "pending sync";
+    }
+    if (dataState === "ingest_failed") {
+        return "sync failed";
+    }
+    if (dataState === "collected_local") {
+        return "local";
+    }
+    return "recent";
+}
+function isAttentionLog(lastRunOutcome, dataState) {
+    return !(dataState === "collected_local" ||
+        dataState === "ingested_personal_server" ||
+        lastRunOutcome === CliOutcomeStatus.CONNECTED_LOCAL_ONLY ||
+        lastRunOutcome === CliOutcomeStatus.CONNECTED_AND_INGESTED);
+}
+function toneForLogOutcome(lastRunOutcome, dataState) {
+    if (lastRunOutcome === CliOutcomeStatus.RUNTIME_ERROR) {
+        return "error";
+    }
+    if (lastRunOutcome === CliOutcomeStatus.CONNECTOR_UNAVAILABLE ||
+        lastRunOutcome === CliOutcomeStatus.LEGACY_AUTH ||
+        lastRunOutcome === CliOutcomeStatus.NEEDS_INPUT ||
+        dataState === "ingest_failed" ||
+        dataState === "ingest_unavailable") {
+        return "warning";
+    }
+    if (dataState === "ingested_personal_server") {
+        return "success";
+    }
+    if (dataState === "collected_local") {
+        return "muted";
+    }
+    return "muted";
+}
+// ---------------------------------------------------------------------------
+// Detach (background process)
+// ---------------------------------------------------------------------------
+async function runDetached(command, source, options) {
+    const emit = createEmitter(options);
+    const registrySources = await loadRegistrySources();
+    const sourceLabels = createSourceLabelMap(registrySources);
+    const displayName = displaySource(source, sourceLabels);
+    // Check if source has been previously connected (has a session to reuse).
+    // Detach is for re-collection with existing sessions, not first-time auth.
+    const state = await readCliState();
+    const sourceState = state.sources[source];
+    if (!sourceState?.lastResultPath && !sourceState?.sessionPresent) {
+        emit.info(`Run ${emit.code(`vana connect ${source}`)} first to authenticate.`);
+        emit.detail("Use --detach for background re-collection after the first connect.");
+        return 1;
+    }
+    const sessionsDir = getSessionsDir();
+    const logsDir = getLogsDir();
+    await fsp.mkdir(sessionsDir, { recursive: true });
+    await fsp.mkdir(logsDir, { recursive: true });
+    const logPath = path.join(logsDir, `${source}-detach.log`);
+    const sessionPath = path.join(sessionsDir, `${source}.json`);
+    const logFd = fs.openSync(logPath, "a");
+    // --no-input: if auth is needed, fail fast and record needs_reauth.
+    // Don't use --ipc: nobody is watching a detached process.
+    const childArgs = [
+        process.argv[1],
+        command,
+        source,
+        "--json",
+        "--quiet",
+        "--no-input",
+    ];
+    const child = spawn(process.execPath, childArgs, {
+        detached: true,
+        stdio: ["ignore", logFd, logFd],
+        env: { ...process.env, VANA_DETACHED: "1" },
+    });
+    trackActiveTelemetryEvent("detached_run_spawned", { source });
+    child.unref();
+    fs.closeSync(logFd);
+    // Write session file
+    const session = {
+        source,
+        command,
+        pid: child.pid,
+        startedAt: new Date().toISOString(),
+        status: "running",
+        logPath,
+    };
+    await fsp.writeFile(sessionPath, `${JSON.stringify(session, null, 2)}\n`);
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify(session)}\n`);
+        return 0;
+    }
+    const verb = command === "connect" ? "Connecting" : "Collecting";
+    emit.info(`${verb} ${displayName} in the background.`);
+    emit.detail(`Check progress: ${emit.code("vana status")}`);
+    return 0;
+}
+// ---------------------------------------------------------------------------
+// Schedule commands
+// ---------------------------------------------------------------------------
+const LAUNCHD_LABEL = "com.vana.collect";
+const LAUNCHD_PLIST_PATH = path.join(os.homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+const CRONTAB_MARKER = "# vana-scheduled-collection";
+const WINDOWS_TASK_NAME = "VanaScheduledCollection";
+function parseIntervalSeconds(interval) {
+    const lower = interval.toLowerCase().trim();
+    const match = /^(\d+)\s*(h|d|m|w)$/i.exec(lower);
+    if (match) {
+        const value = parseInt(match[1], 10);
+        const unit = match[2].toLowerCase();
+        if (unit === "h")
+            return value * 3600;
+        if (unit === "d")
+            return value * 86400;
+        if (unit === "w")
+            return value * 7 * 86400;
+        if (unit === "m")
+            return value * 30 * 86400;
+    }
+    if (lower === "daily")
+        return 86400;
+    if (lower === "weekly")
+        return 7 * 86400;
+    // Default to 24h
+    return 86400;
+}
+function formatIntervalHuman(seconds) {
+    if (seconds < 3600)
+        return `${Math.round(seconds / 60)}m`;
+    if (seconds < 86400)
+        return `${Math.round(seconds / 3600)}h`;
+    return `${Math.round(seconds / 86400)}d`;
+}
+function resolveVanaBinaryPath() {
+    // For SEA binaries, process.execPath is the binary itself
+    const installMethod = getCliInstallMethod();
+    if (installMethod === "homebrew" || installMethod === "installer") {
+        return process.execPath;
+    }
+    // For development, try to find the vana binary via which/where
+    try {
+        const cmd = process.platform === "win32" ? "where vana" : "which vana";
+        const result = execSync(cmd, { encoding: "utf8" }).trim();
+        // `where` on Windows may return multiple lines; take the first
+        return result.split("\n")[0].trim();
+    }
+    catch {
+        // Fall back to process.execPath + argv[1]
+        return `${process.execPath} ${process.argv[1]}`;
+    }
+}
+async function getExistingScheduleInterval() {
+    if (process.platform === "darwin") {
+        try {
+            const content = await fsp.readFile(LAUNCHD_PLIST_PATH, "utf8");
+            const match = content.match(/<key>StartInterval<\/key>\s*<integer>(\d+)<\/integer>/);
+            return match ? parseInt(match[1], 10) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    if (process.platform === "linux") {
+        try {
+            const crontab = execSync("crontab -l 2>/dev/null", { encoding: "utf8" });
+            const vanaLine = crontab
+                .split("\n")
+                .find((line) => line.includes(CRONTAB_MARKER));
+            if (!vanaLine)
+                return null;
+            // Parse hour interval from crontab: look for */N pattern
+            const hourMatch = /\*\/(\d+)/.exec(vanaLine);
+            if (hourMatch)
+                return parseInt(hourMatch[1], 10) * 3600;
+            // Daily (0 0 * * *)
+            return 86400;
+        }
+        catch {
+            return null;
+        }
+    }
+    if (process.platform === "win32") {
+        try {
+            execSync(`schtasks /Query /TN "${WINDOWS_TASK_NAME}" /FO LIST`, {
+                encoding: "utf8",
+            });
+            // Task exists but we can't easily parse the interval; return a
+            // sentinel value (86400) to indicate "schedule present".
+            return 86400;
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+async function maybeAutoSchedule(emit, options) {
+    // Skip if --no-input (detached/agent context shouldn't create schedules)
+    if (options.noInput)
+        return;
+    // Skip unsupported platforms
+    if (!["darwin", "linux", "win32"].includes(process.platform))
+        return;
+    const existing = await getExistingScheduleInterval();
+    if (existing !== null)
+        return; // Schedule already exists
+    await runScheduleAdd("daily", { json: false, quiet: true });
+    emit.detail("Auto-scheduled daily collection.");
+}
+function generateLaunchdPlist(vanaBinary, intervalSeconds) {
+    const logsPath = path.join(getLogsDir(), "schedule.log");
+    // Handle the case where vanaBinary might contain a space (node + script)
+    const programArgs = vanaBinary.includes(" ")
+        ? vanaBinary
+            .split(" ")
+            .map((arg) => `    <string>${arg}</string>`)
+            .join("\n")
+        : `    <string>${vanaBinary}</string>`;
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCHD_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${programArgs}
+    <string>collect</string>
+    <string>--all</string>
+    <string>--quiet</string>
+    <string>--no-input</string>
+  </array>
+  <key>StartInterval</key>
+  <integer>${intervalSeconds}</integer>
+  <key>StandardOutPath</key>
+  <string>${logsPath}</string>
+  <key>StandardErrorPath</key>
+  <string>${logsPath}</string>
+  <key>RunAtLoad</key>
+  <true/>
+</dict>
+</plist>
+`;
+}
+function generateCrontabEntry(vanaBinary, intervalHours) {
+    const logsPath = path.join(getLogsDir(), "schedule.log");
+    const hourExpr = intervalHours >= 24 ? "0" : `0`;
+    const dayExpr = "*";
+    const hourInterval = intervalHours >= 24 ? "0" : intervalHours >= 1 ? `*/${intervalHours}` : "*";
+    return `${hourExpr} ${hourInterval} ${dayExpr} * * ${vanaBinary} collect --all --quiet --no-input >> ${logsPath} 2>&1 ${CRONTAB_MARKER}`;
+}
+async function runScheduleAdd(interval, options) {
+    const emit = createEmitter(options);
+    const intervalSeconds = parseIntervalSeconds(interval);
+    const intervalLabel = formatIntervalHuman(intervalSeconds);
+    const vanaBinary = resolveVanaBinaryPath();
+    await fsp.mkdir(getLogsDir(), { recursive: true });
+    if (process.platform === "darwin") {
+        // macOS: launchd
+        const plist = generateLaunchdPlist(vanaBinary, intervalSeconds);
+        const plistDir = path.dirname(LAUNCHD_PLIST_PATH);
+        await fsp.mkdir(plistDir, { recursive: true });
+        // Unload existing if present
+        try {
+            execSync(`launchctl unload "${LAUNCHD_PLIST_PATH}" 2>/dev/null`, {
+                stdio: "ignore",
+            });
+        }
+        catch {
+            // Not loaded, that's fine
+        }
+        await fsp.writeFile(LAUNCHD_PLIST_PATH, plist);
+        try {
+            execSync(`launchctl load "${LAUNCHD_PLIST_PATH}"`, { stdio: "ignore" });
+        }
+        catch {
+            emit.info("Could not load the launchd plist. Load it manually:");
+            emit.detail(`launchctl load "${LAUNCHD_PLIST_PATH}"`);
+            return 1;
+        }
+        trackActiveTelemetryEvent("schedule_added", {
+            metadata: { interval: intervalLabel, mechanism: "launchd" },
+        });
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({ ok: true, interval: intervalLabel, mechanism: "launchd", plistPath: LAUNCHD_PLIST_PATH })}\n`);
+            return 0;
+        }
+        emit.info(`Added ${intervalLabel === "1d" ? "daily" : `every ${intervalLabel}`} collection schedule.`);
+        emit.detail(`Runs: ${emit.code("vana collect --all --quiet")}`);
+        emit.detail(`Managed by: launchd`);
+        return 0;
+    }
+    if (process.platform === "linux") {
+        // Linux: cron doesn't defer missed jobs (unlike launchd), so we run
+        // hourly and let isCollectionDue() filter per-source. This way a
+        // missed 2am tick self-heals at 3am instead of waiting 24h.
+        const entry = generateCrontabEntry(vanaBinary, 1);
+        try {
+            // Read existing crontab, filter out old vana entries, add new one
+            let existing = "";
+            try {
+                existing = execSync("crontab -l 2>/dev/null", {
+                    encoding: "utf8",
+                });
+            }
+            catch {
+                // No existing crontab
+            }
+            const filtered = existing
+                .split("\n")
+                .filter((line) => !line.includes(CRONTAB_MARKER))
+                .join("\n");
+            const newCrontab = `${filtered.trimEnd()}\n${entry}\n`;
+            execSync("crontab -", {
+                input: newCrontab,
+                encoding: "utf8",
+            });
+        }
+        catch {
+            emit.info("Could not update crontab. Add this entry manually:");
+            emit.detail(entry);
+            return 1;
+        }
+        trackActiveTelemetryEvent("schedule_added", {
+            metadata: { interval: intervalLabel, mechanism: "cron" },
+        });
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({ ok: true, interval: intervalLabel, mechanism: "cron" })}\n`);
+            return 0;
+        }
+        emit.info(`Added ${intervalLabel === "1d" ? "daily" : `every ${intervalLabel}`} collection schedule.`);
+        emit.detail(`Runs: ${emit.code("vana collect --all --quiet")}`);
+        emit.detail(`Managed by: cron`);
+        return 0;
+    }
+    if (process.platform === "win32") {
+        // Windows: Task Scheduler
+        const intervalMinutes = Math.max(1, Math.round(intervalSeconds / 60));
+        const trCmd = `\\"${vanaBinary}\\" collect --all --quiet --no-input`;
+        try {
+            try {
+                execSync(`schtasks /Delete /TN "${WINDOWS_TASK_NAME}" /F 2>nul`, {
+                    stdio: "ignore",
+                });
+            }
+            catch {
+                // Not present, that's fine
+            }
+            if (intervalSeconds >= 86400) {
+                execSync(`schtasks /Create /TN "${WINDOWS_TASK_NAME}" /TR "${trCmd}" /SC DAILY /ST 09:00 /F`, { stdio: "ignore" });
+            }
+            else {
+                execSync(`schtasks /Create /TN "${WINDOWS_TASK_NAME}" /TR "${trCmd}" /SC MINUTE /MO ${intervalMinutes} /F`, { stdio: "ignore" });
+            }
+            // Enable StartWhenAvailable for deferred execution
+            try {
+                execSync(`powershell -Command "$t = Get-ScheduledTask '${WINDOWS_TASK_NAME}'; $t.Settings.StartWhenAvailable = $true; Set-ScheduledTask -InputObject $t"`, { stdio: "ignore" });
+            }
+            catch {
+                // Non-fatal if PowerShell cmdlet fails
+            }
+        }
+        catch {
+            emit.info("Could not create scheduled task. Create it manually:");
+            emit.detail(`schtasks /Create /TN "${WINDOWS_TASK_NAME}" /TR "${trCmd}" /SC DAILY /ST 09:00 /F`);
+            return 1;
+        }
+        trackActiveTelemetryEvent("schedule_added", {
+            metadata: { interval: intervalLabel, mechanism: "schtasks" },
+        });
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({ ok: true, interval: intervalLabel, mechanism: "schtasks" })}\n`);
+            return 0;
+        }
+        emit.info(`Added ${intervalLabel === "1d" ? "daily" : `every ${intervalLabel}`} collection schedule.`);
+        emit.detail(`Runs: ${emit.code("vana collect --all --quiet")}`);
+        emit.detail(`Managed by: Task Scheduler`);
+        return 0;
+    }
+    // Unsupported platform
+    emit.info("Scheduled collection is not supported on this platform. Run `vana collect --all` manually.");
+    return 1;
+}
+async function runScheduleList(options) {
+    const emit = createEmitter(options);
+    if (process.platform === "darwin") {
+        // Check launchd plist
+        try {
+            await fsp.access(LAUNCHD_PLIST_PATH);
+            const content = await fsp.readFile(LAUNCHD_PLIST_PATH, "utf8");
+            const intervalMatch = content.match(/<key>StartInterval<\/key>\s*<integer>(\d+)<\/integer>/);
+            const intervalSeconds = intervalMatch
+                ? parseInt(intervalMatch[1], 10)
+                : 86400;
+            const intervalLabel = formatIntervalHuman(intervalSeconds);
+            const nextInSeconds = intervalSeconds; // Approximate; launchd doesn't expose exact next-run
+            const nextLabel = `~${formatIntervalHuman(nextInSeconds)}`;
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify({
+                    scheduled: true,
+                    interval: intervalLabel,
+                    intervalSeconds,
+                    mechanism: "launchd",
+                    plistPath: LAUNCHD_PLIST_PATH,
+                })}\n`);
+                return 0;
+            }
+            emit.keyValue("Daily collection", `every ${intervalLabel}    next: ${nextLabel}`, "muted");
+            emit.detail(`Managed by: ${LAUNCHD_PLIST_PATH}`);
+            return 0;
+        }
+        catch {
+            // No plist found
+        }
+    }
+    if (process.platform === "linux") {
+        // Check crontab
+        try {
+            const crontab = execSync("crontab -l 2>/dev/null", {
+                encoding: "utf8",
+            });
+            const vanaLine = crontab
+                .split("\n")
+                .find((line) => line.includes(CRONTAB_MARKER));
+            if (vanaLine) {
+                if (options.json) {
+                    process.stdout.write(`${JSON.stringify({
+                        scheduled: true,
+                        mechanism: "cron",
+                        entry: vanaLine,
+                    })}\n`);
+                    return 0;
+                }
+                emit.keyValue("Daily collection", "cron", "muted");
+                emit.detail(`Entry: ${vanaLine.replace(CRONTAB_MARKER, "").trim()}`);
+                return 0;
+            }
+        }
+        catch {
+            // No crontab available
+        }
+    }
+    if (process.platform === "win32") {
+        try {
+            const output = execSync(`schtasks /Query /TN "${WINDOWS_TASK_NAME}" /FO LIST`, { encoding: "utf8" });
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify({
+                    scheduled: true,
+                    mechanism: "schtasks",
+                    taskName: WINDOWS_TASK_NAME,
+                })}\n`);
+                return 0;
+            }
+            emit.keyValue("Daily collection", "Task Scheduler", "muted");
+            // Extract schedule info from output
+            const statusLine = output.split("\n").find((l) => l.includes("Status:"));
+            if (statusLine) {
+                emit.detail(statusLine.trim());
+            }
+            return 0;
+        }
+        catch {
+            // Task not found
+        }
+    }
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({ scheduled: false })}\n`);
+        return 0;
+    }
+    emit.info("No scheduled collection found.");
+    emit.detail(`Add one with ${emit.code("vana schedule add")}.`);
+    return 0;
+}
+async function runScheduleRemove(options) {
+    const emit = createEmitter(options);
+    if (process.platform === "darwin") {
+        try {
+            await fsp.access(LAUNCHD_PLIST_PATH);
+            try {
+                execSync(`launchctl unload "${LAUNCHD_PLIST_PATH}"`, {
+                    stdio: "ignore",
+                });
+            }
+            catch {
+                // Already unloaded
+            }
+            await fsp.unlink(LAUNCHD_PLIST_PATH);
+            trackActiveTelemetryEvent("schedule_removed", {
+                metadata: { mechanism: "launchd" },
+            });
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify({ ok: true, removed: true })}\n`);
+                return 0;
+            }
+            emit.info("Removed daily collection schedule.");
+            return 0;
+        }
+        catch {
+            // No plist found, fall through
+        }
+    }
+    if (process.platform === "linux") {
+        try {
+            const existing = execSync("crontab -l 2>/dev/null", {
+                encoding: "utf8",
+            });
+            if (existing.includes(CRONTAB_MARKER)) {
+                const filtered = existing
+                    .split("\n")
+                    .filter((line) => !line.includes(CRONTAB_MARKER))
+                    .join("\n");
+                execSync("crontab -", {
+                    input: `${filtered.trimEnd()}\n`,
+                    encoding: "utf8",
+                });
+                trackActiveTelemetryEvent("schedule_removed", {
+                    metadata: { mechanism: "cron" },
+                });
+                if (options.json) {
+                    process.stdout.write(`${JSON.stringify({ ok: true, removed: true })}\n`);
+                    return 0;
+                }
+                emit.info("Removed daily collection schedule.");
+                return 0;
+            }
+        }
+        catch {
+            // No crontab available
+        }
+    }
+    if (process.platform === "win32") {
+        try {
+            execSync(`schtasks /Delete /TN "${WINDOWS_TASK_NAME}" /F`, {
+                stdio: "ignore",
+            });
+            trackActiveTelemetryEvent("schedule_removed", {
+                metadata: { mechanism: "schtasks" },
+            });
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify({ ok: true, removed: true })}\n`);
+                return 0;
+            }
+            emit.info("Removed daily collection schedule.");
+            return 0;
+        }
+        catch {
+            // Task not found
+        }
+    }
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({ ok: true, removed: false })}\n`);
+        return 0;
+    }
+    emit.info("No scheduled collection found to remove.");
+    return 0;
+}
+function isPromptCancelled(error) {
+    return (error instanceof Error &&
+        (error.name === "ExitPromptError" || error.message.includes("SIGINT")));
+}
+// ---------------------------------------------------------------------------
+// Skill commands
+// ---------------------------------------------------------------------------
+const BASE_SKILL_ID = "connect-data";
+async function maybePromptSkillInstall(emit) {
+    try {
+        const skills = await listAvailableSkills();
+        const baseSkill = skills.find((s) => s.id === BASE_SKILL_ID);
+        if (!baseSkill)
+            return;
+        const installed = await readInstalledSkills();
+        if (installed.some((s) => s.id === BASE_SKILL_ID)) {
+            await updateCliConfig({ skillsPromptCompleted: true });
+            return;
+        }
+        emit.blank();
+        const shouldInstall = await confirm({
+            message: "Install a skill so your coding agent knows how to use your connected data?",
+            default: true,
+            ...vanaPromptTheme,
+        });
+        if (shouldInstall) {
+            try {
+                await installSkill(BASE_SKILL_ID);
+                emit.success(`Installed skill: ${baseSkill.name}`);
+            }
+            catch {
+                // Non-fatal.
+            }
+            const remaining = skills.filter((s) => s.id !== BASE_SKILL_ID);
+            if (remaining.length > 0) {
+                emit.next("vana skills");
+            }
+        }
+        await updateCliConfig({ skillsPromptCompleted: true });
+    }
+    catch {
+        // Prompt cancelled or error — mark as completed to avoid re-asking.
+        await updateCliConfig({ skillsPromptCompleted: true });
+    }
+}
+async function runSkillsGuidedPicker(options) {
+    const emit = createEmitter(options);
+    if (options.json) {
+        // In JSON mode, fall back to list behavior
+        return runSkillList(options);
+    }
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        return runSkillList(options);
+    }
+    try {
+        const skills = await listAvailableSkills();
+        const installed = await readInstalledSkills();
+        const installedIds = new Set(installed.map((s) => s.id));
+        if (skills.length === 0) {
+            emit.info("No skills are available right now.");
+            return 0;
+        }
+        const choices = skills.map((skill) => {
+            const isInstalled = installedIds.has(skill.id);
+            return {
+                value: skill.id,
+                name: `${skill.name}${isInstalled ? " (installed)" : ""}`,
+                description: skill.description,
+            };
+        });
+        const selectedId = await searchSelect({
+            message: "Select a skill.",
+            choices,
+            ...vanaPromptTheme,
+        });
+        if (installedIds.has(selectedId)) {
+            return runSkillShow(selectedId, options);
+        }
+        return runSkillInstall(selectedId, options);
+    }
+    catch (error) {
+        if (isPromptCancelled(error)) {
+            emit.info("Cancelled.");
+            return 1;
+        }
+        throw error;
+    }
+}
+async function runSkillList(options) {
+    const emit = createEmitter(options);
+    try {
+        const skills = await listAvailableSkills();
+        const installed = await readInstalledSkills();
+        const installedIds = new Set(installed.map((s) => s.id));
+        const enriched = skills.map((skill) => ({
+            ...skill,
+            installed: installedIds.has(skill.id),
+        }));
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({ count: enriched.length, skills: enriched })}\n`);
+            return 0;
+        }
+        emit.title("Available skills");
+        emit.blank();
+        if (enriched.length === 0) {
+            emit.info("No skills are available right now.");
+            return 0;
+        }
+        for (const skill of enriched) {
+            const tag = skill.installed
+                ? ` ${emit.badge("installed", "accent")}`
+                : "";
+            emit.info(`  ${skill.name}${tag}`);
+            emit.detail(`  ${skill.description}`);
+        }
+        const uninstalled = enriched.find((s) => !s.installed);
+        if (uninstalled) {
+            emit.blank();
+            emit.next(`vana skills install ${uninstalled.id}`);
+        }
+        return 0;
+    }
+    catch (error) {
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({ error: error instanceof Error ? error.message : String(error) })}\n`);
+        }
+        else {
+            emit.info(error instanceof Error ? error.message : String(error));
+        }
+        return 1;
+    }
+}
+async function runSkillInstall(name, options) {
+    const emit = createEmitter(options);
+    try {
+        const { installedPath } = await installSkill(name);
+        trackActiveTelemetryEvent("skill_installed", {
+            metadata: { skillName: name },
+        });
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({ ok: true, id: name, installedPath })}\n`);
+            return 0;
+        }
+        emit.success(`Installed ${name}.`);
+        emit.blank();
+        const skills = await listAvailableSkills();
+        const installed = await readInstalledSkills();
+        const installedIds = new Set([...installed.map((s) => s.id), name]);
+        const nextSkill = skills.find((s) => !installedIds.has(s.id));
+        emit.next(nextSkill ? `vana skills install ${nextSkill.id}` : "vana skills list");
+        return 0;
+    }
+    catch (error) {
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({ ok: false, error: error instanceof Error ? error.message : String(error) })}\n`);
+        }
+        else {
+            emit.info(error instanceof Error ? error.message : String(error));
+        }
+        return 1;
+    }
+}
+async function runSkillShow(name, options) {
+    const emit = createEmitter(options);
+    try {
+        const skills = await listAvailableSkills();
+        const match = skills.find((s) => s.id.toLowerCase() === name.toLowerCase());
+        if (!match) {
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify({ error: `No skill found with id "${name}".` })}\n`);
+            }
+            else {
+                emit.info(`No skill found with id "${name}".`);
+                emit.blank();
+                emit.next("vana skills list");
+            }
+            return 1;
+        }
+        const installed = await readInstalledSkills();
+        const isInstalled = installed.some((s) => s.id === match.id);
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({ ...match, installed: isInstalled })}\n`);
+            return 0;
+        }
+        const badges = [];
+        if (isInstalled) {
+            badges.push({ text: "installed", tone: "success" });
+        }
+        emit.sourceTitle(match.name, badges);
+        emit.detail(match.description);
+        emit.keyValue("Version", match.version);
+        if (!isInstalled) {
+            emit.blank();
+            emit.next(`vana skills install ${match.id}`);
+        }
+        return 0;
+    }
+    catch (error) {
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({ error: error instanceof Error ? error.message : String(error) })}\n`);
+        }
+        else {
+            emit.info(error instanceof Error ? error.message : String(error));
+        }
+        return 1;
+    }
+}
+// ── Login / Logout ─────────────────────────────────────────────────────
+async function runLogin(options, serverUrl, clientId) {
+    // Determine auth target: cloud (account.vana.org) or self-hosted (PS directly)
+    const psUrl = serverUrl ?? resolvePersonalServerUrl() ?? null;
+    const authTarget = getAuthTarget(psUrl);
+    // If self-hosted, use /auth/device flow against the PS
+    if (authTarget === "self-hosted" && psUrl) {
+        const renderer = !options.json && !options.quiet ? createLoginRenderer() : null;
+        const humanRenderer = createHumanRenderer();
+        renderer?.title(psUrl);
+        try {
+            const result = await runSelfHostedLoginFlow(psUrl, (url) => {
+                if (!options.json && !options.quiet) {
+                    process.stderr.write(`  ${humanRenderer.theme.muted("Open this URL in your browser:")}\n`);
+                    process.stderr.write(`  ${humanRenderer.theme.muted(url)}\n`);
+                }
+                renderer?.scopeActive("Waiting for authorization");
+                // Try to open browser — use spawn with args array to prevent shell injection
+                // (a malicious self-hosted PS could return a URL with shell metacharacters)
+                try {
+                    const { spawn } = require("node:child_process");
+                    const opener = process.platform === "darwin"
+                        ? "open"
+                        : process.platform === "win32"
+                            ? "start"
+                            : "xdg-open";
+                    spawn(opener, [url], { detached: true, stdio: "ignore" }).unref();
+                }
+                catch {
+                    // Browser open failed — user will open manually
+                }
+            });
+            await saveCredentials({
+                account: {
+                    address: result.address,
+                    session_token: "",
+                    expires_at: result.expires_at,
+                },
+                personal_server: {
+                    url: psUrl,
+                    session_token: result.session_token,
+                    expires_at: result.expires_at,
+                },
+            });
+            await updateCliConfig({ personalServerUrl: psUrl });
+            renderer?.success(`Logged in to ${psUrl}`);
+            renderer?.detail("Credentials saved to ~/.vana/auth.json");
+            return 0;
+        }
+        catch (err) {
+            renderer?.fail("Login failed");
+            renderer?.detail(err instanceof Error ? err.message : String(err));
+            renderer?.next(`vana login --server ${psUrl}`);
+            return 1;
+        }
+        finally {
+            renderer?.cleanup();
+        }
+    }
+    // Cloud flow (account.vana.org)
+    // Check env var shortcut
+    const envToken = process.env.VANA_SESSION_TOKEN;
+    if (envToken) {
+        const creds = loadCredentials();
+        if (creds) {
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify({ status: "authenticated", source: "env", address: creds.account.address })}\n`);
+            }
+            else {
+                const emit = createEmitter(options);
+                emit.success(`Already authenticated via VANA_SESSION_TOKEN env var`);
+            }
+            return 0;
+        }
+    }
+    // Check if already logged in
+    const existing = loadCredentials();
+    if (existing && !isExpired(existing)) {
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({
+                status: "authenticated",
+                address: existing.account.address,
+                personal_server: existing.personal_server?.url ?? null,
+                expires_at: existing.account.expires_at,
+            })}\n`);
+        }
+        else {
+            const emit = createEmitter(options);
+            emit.success(`Already logged in as ${formatAddress(existing.account.address)}`);
+            if (existing.personal_server) {
+                emit.keyValue("Personal Server", existing.personal_server.url, "success");
+            }
+            emit.info(`  Auth expires in ${formatExpiresIn(existing.account.expires_at)}`);
+            emit.blank();
+            emit.info("  Run `vana logout` first to re-authenticate.");
+        }
+        return 0;
+    }
+    if (options.json) {
+        // JSON mode: run flow and output result
+        const creds = await runDeviceCodeFlow({
+            onCode: (code, uri) => {
+                process.stderr.write(JSON.stringify({ event: "device_code", code, uri }) + "\n");
+            },
+            onWaiting: () => { },
+            onAuthorized: () => { },
+            onExpired: () => {
+                process.stdout.write(JSON.stringify({
+                    status: "expired",
+                    error: "Device code expired",
+                }) + "\n");
+            },
+            onError: (err) => {
+                process.stdout.write(JSON.stringify({ status: "error", error: err.message }) + "\n");
+            },
+        }, { clientId });
+        if (creds) {
+            await saveCredentials(creds);
+            if (creds.personal_server?.url) {
+                await updateCliConfig({ personalServerUrl: creds.personal_server.url });
+            }
+            process.stdout.write(`${JSON.stringify({
+                status: "authenticated",
+                address: creds.account.address,
+                personal_server: creds.personal_server?.url ?? null,
+                expires_at: creds.account.expires_at,
+            })}\n`);
+            return 0;
+        }
+        return 1;
+    }
+    // Interactive mode
+    const renderer = createLoginRenderer();
+    const humanRenderer = createHumanRenderer();
+    const writeStaticLoginNotes = (lines) => {
+        if (options.json || options.quiet) {
+            return;
+        }
+        for (const line of lines) {
+            process.stderr.write(`  ${humanRenderer.theme.muted(line)}\n`);
+        }
+    };
+    renderer.title("Vana");
+    const creds = await runDeviceCodeFlow({
+        onCode: (code, uri) => {
+            writeStaticLoginNotes([
+                "Open this URL in your browser:",
+                uri,
+                `Enter this code: ${code}`,
+            ]);
+        },
+        onWaiting: () => {
+            renderer.scopeActive("Waiting for authorization");
+        },
+        onAuthorized: async (authedCreds) => {
+            await saveCredentials(authedCreds);
+            if (authedCreds.personal_server?.url) {
+                await updateCliConfig({
+                    personalServerUrl: authedCreds.personal_server.url,
+                });
+            }
+            renderer.success(`Logged in as ${formatAddress(authedCreds.account.address)}`);
+            if (authedCreds.personal_server) {
+                renderer.detail(`Personal Server: ${authedCreds.personal_server.url}`);
+            }
+            renderer.detail("Credentials saved to ~/.vana/auth.json");
+        },
+        onExpired: () => {
+            renderer.fail("Authorization expired");
+            renderer.next("vana login");
+        },
+        onError: (err) => {
+            renderer.fail("Login failed");
+            renderer.detail(err.message);
+            renderer.next("vana login");
+        },
+    }, { clientId });
+    renderer.cleanup();
+    return creds ? 0 : 1;
+}
+async function runLogout(options) {
+    // Revoke the token server-side before clearing local credentials
+    const creds = loadCredentials();
+    if (creds?.personal_server?.url && creds.personal_server.session_token) {
+        try {
+            await fetch(`${creds.personal_server.url.replace(/\/$/, "")}/auth/device/token`, {
+                method: "DELETE",
+                headers: {
+                    Authorization: `Bearer ${creds.personal_server.session_token}`,
+                },
+                signal: AbortSignal.timeout(5000),
+            });
+        }
+        catch {
+            // Best-effort — server may be down, but we still clear local creds
+        }
+    }
+    await clearCredentials();
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({ status: "logged_out" })}\n`);
+    }
+    else {
+        const emit = createEmitter(options);
+        emit.success("Logged out. Credentials removed.");
+    }
+    return 0;
+}
+//# sourceMappingURL=index.js.map