maqcli 0.2.0 → 0.4.0

package/dist/core/capabilities.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Capability tiering — the brain behind "pick an EFFICIENT model, not the
+ * cheapest and not the most expensive".
+ *
+ * Every model the launcher discovers (from the static catalog, from a worker
+ * CLI's /models list, or from a live provider) is classified into one of three
+ * tiers. The guided launcher's AUTO choice for the Headroom model is the best
+ * available MID model: enough capability to manage the whole god-level flow
+ * without paying for max power or crippling it with a toy model.
+ *
+ *   light  — triage/summaries/cheap fan-out workers
+ *   mid    — the efficient default: plans, routing, Headroom management
+ *   heavy  — reserved for the hardest single steps (opt-in / manual)
+ */
+export type CapabilityTier = "light" | "mid" | "heavy";
+export interface TieredModel {
+    id: string;
+    provider: string;
+    /** MAQ provider name for getProvider(). */
+    maqProvider: string;
+    tier: CapabilityTier;
+    vision?: boolean;
+    longContext?: boolean;
+}
+/**
+ * Heuristic classifier for a raw model id when we have no catalog tag (e.g. a
+ * model name returned by a CLI's `/models`). Pattern-based, deterministic.
+ */
+export declare function classifyModel(id: string): CapabilityTier;
+export declare function tierRank(t: CapabilityTier): number;
+/**
+ * Pick the efficient model from a set of available tiered models.
+ *
+ * Preference: a MID model first; if none, fall back to the strongest LIGHT
+ * (so we never silently jump to an expensive HEAVY as the "auto efficient"
+ * default). If only HEAVY exists, use it but flag it.
+ */
+export declare function pickEfficient(models: TieredModel[]): {
+    model: TieredModel;
+    note: string;
+} | null;
+/** Split a set of models into their tier buckets (for display). */
+export declare function groupByTier(models: TieredModel[]): Record<CapabilityTier, TieredModel[]>;
+/**
+ * The instruction MAQ hands a worker CLI (option 1) so it self-reports its
+ * capabilities in a machine-parseable form. Kept tiny and format-strict so the
+ * reply can be stored directly into the Headroom knowledge doc.
+ */
+export declare const CAPABILITY_PROBE_INSTRUCTION: string;
+/** Parse a capability-probe reply into a partial TieredModel-ish record. */
+export declare function parseCapabilityReply(reply: string): {
+    tier: CapabilityTier;
+    strengths: string[];
+    contextTokens?: number;
+    vision?: boolean;
+    goodFor: string[];
+} | null;

package/dist/core/capabilities.js

@@ -0,0 +1,106 @@
+/**
+ * Capability tiering — the brain behind "pick an EFFICIENT model, not the
+ * cheapest and not the most expensive".
+ *
+ * Every model the launcher discovers (from the static catalog, from a worker
+ * CLI's /models list, or from a live provider) is classified into one of three
+ * tiers. The guided launcher's AUTO choice for the Headroom model is the best
+ * available MID model: enough capability to manage the whole god-level flow
+ * without paying for max power or crippling it with a toy model.
+ *
+ *   light  — triage/summaries/cheap fan-out workers
+ *   mid    — the efficient default: plans, routing, Headroom management
+ *   heavy  — reserved for the hardest single steps (opt-in / manual)
+ */
+/**
+ * Heuristic classifier for a raw model id when we have no catalog tag (e.g. a
+ * model name returned by a CLI's `/models`). Pattern-based, deterministic.
+ */
+export function classifyModel(id) {
+    const s = id.toLowerCase();
+    // Heavy: flagship / reasoning / "pro"/"opus"/"large"/"ultra" families.
+    if (/(opus|-4\.1$|-4\.5|ultra|large|o3\b|reasoner|r1\b|pro\b|405b|grok-4)/.test(s)) {
+        return "heavy";
+    }
+    // Reasoning "mini" models (o1/o3/o4-mini) are efficient MID, not light.
+    if (/\bo[1345]-mini/.test(s)) {
+        return "mid";
+    }
+    // Light: explicitly small / fast / nano / haiku / mini / 8b / flash-lite.
+    // NB: \bmini avoids matching "geMINI".
+    if (/(nano|\bmini|instant|haiku|flash-lite|-8b|-7b|1\.5-flash|3\.2$|small)/.test(s)) {
+        return "light";
+    }
+    // Mid: the efficient middle — flash, sonnet, medium, 70b, coder.
+    if (/(flash|sonnet|medium|70b|coder|grok-3|deepseek-chat)/.test(s)) {
+        return "mid";
+    }
+    // Default unknown to mid so AUTO stays "efficient" rather than risky.
+    return "mid";
+}
+const TIER_ORDER = { light: 0, mid: 1, heavy: 2 };
+export function tierRank(t) {
+    return TIER_ORDER[t];
+}
+/**
+ * Pick the efficient model from a set of available tiered models.
+ *
+ * Preference: a MID model first; if none, fall back to the strongest LIGHT
+ * (so we never silently jump to an expensive HEAVY as the "auto efficient"
+ * default). If only HEAVY exists, use it but flag it.
+ */
+export function pickEfficient(models) {
+    if (models.length === 0)
+        return null;
+    const mids = models.filter((m) => m.tier === "mid");
+    if (mids.length > 0) {
+        // Prefer a mid model with long context (better for Headroom management).
+        const best = mids.find((m) => m.longContext) ?? mids[0];
+        return { model: best, note: "efficient mid-tier: balanced capability vs cost" };
+    }
+    const lights = models.filter((m) => m.tier === "light");
+    if (lights.length > 0) {
+        return { model: lights[0], note: "no mid model available; using the strongest light model" };
+    }
+    return { model: models[0], note: "only heavy models available; consider a mid model to save cost" };
+}
+/** Split a set of models into their tier buckets (for display). */
+export function groupByTier(models) {
+    const out = { light: [], mid: [], heavy: [] };
+    for (const m of models)
+        out[m.tier].push(m);
+    return out;
+}
+/**
+ * The instruction MAQ hands a worker CLI (option 1) so it self-reports its
+ * capabilities in a machine-parseable form. Kept tiny and format-strict so the
+ * reply can be stored directly into the Headroom knowledge doc.
+ */
+export const CAPABILITY_PROBE_INSTRUCTION = [
+    "You are being registered as a worker model inside the MAQ orchestrator.",
+    "Reply with ONLY a compact JSON object, no prose, in exactly this shape:",
+    '{"tier":"light|mid|heavy","strengths":["..."],"context_tokens":<int>,"vision":<bool>,"good_for":["plan"|"code"|"review"|"summarize"|"fan-out"]}',
+    "Base it on your own known capabilities. Do not include markdown fences.",
+].join("\n");
+/** Parse a capability-probe reply into a partial TieredModel-ish record. */
+export function parseCapabilityReply(reply) {
+    const trimmed = reply.trim().replace(/^```(json)?/i, "").replace(/```$/, "").trim();
+    const start = trimmed.indexOf("{");
+    const end = trimmed.lastIndexOf("}");
+    if (start === -1 || end === -1 || end <= start)
+        return null;
+    try {
+        const j = JSON.parse(trimmed.slice(start, end + 1));
+        const tier = ["light", "mid", "heavy"].includes(j.tier) ? j.tier : "mid";
+        return {
+            tier,
+            strengths: Array.isArray(j.strengths) ? j.strengths.map(String) : [],
+            contextTokens: typeof j.context_tokens === "number" ? j.context_tokens : undefined,
+            vision: Boolean(j.vision),
+            goodFor: Array.isArray(j.good_for) ? j.good_for.map(String) : [],
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/core/command-catalog.js

@@ -18,6 +18,12 @@ export const maqCommands = [
             { name: "audit", type: "boolean", description: "write hash-chained audit log" },
         ] },
     { name: "scout", category: "pipeline", summary: "Read-only recon; structured findings (0 tokens).", usage: 'maq scout "<task>"', needsInput: "task", args: [] },
+    { name: "orchestrate", category: "pipeline", summary: "Run a goal through the parallel/loop/safe execution engine.", usage: 'maq orchestrate "<goal>" -m parallel|loop|safe', needsInput: "task",
+        args: [
+            { name: "mode", type: "enum", choices: ["parallel", "loop", "safe"], required: true, description: "execution engine" },
+            { name: "target", type: "enum", choices: ["auto", "claude-code", "codex", "gemini", "none"], description: "worker CLI" },
+            { name: "concurrency", type: "string", description: "max parallel sub-tasks" },
+        ] },
     { name: "plan", category: "pipeline", summary: "Verifier-gated candidate plan.", usage: 'maq plan "<task>"', needsInput: "task", args: [] },
     { name: "verify", category: "pipeline", summary: "Run project tests / cross-model review.", usage: "maq verify [--cwd d]", needsInput: "none", args: [] },
     { name: "swarm", category: "pipeline", summary: "Run several tasks across parallel workers, then join.", usage: 'maq swarm "<t1>" "<t2>" … [--target t] [--concurrency N]', needsInput: "none", args: [{ name: "concurrency", type: "string", description: "max parallel workers" }] },

package/dist/core/config-store.d.ts

@@ -23,6 +23,14 @@ export interface MaqConfig {
     projectTargets: Record<string, string>;
     /** Default permission level (strict or standard) */
     defaultPermission: string;
+    /** Guided-launcher posture: "full" (all allowed) | "moderate" (request-box). */
+    permissionMode: string;
+    /** Default execution strategy: "parallel" | "loop" | "safe". */
+    executionMode: string;
+    /** The efficient (mid) model the Headroom master runs on; "" = auto. */
+    headroomModel: string;
+    /** True once the guided launcher has completed first-run setup. */
+    onboarded: boolean;
 }
 export declare const DEFAULT_CONFIG: MaqConfig;
 export declare function configDir(): string;

package/dist/core/config-store.js

@@ -15,6 +15,10 @@ export const DEFAULT_CONFIG = {
     compactionThreshold: 0.6,
     projectTargets: {},
     defaultPermission: "standard",
+    permissionMode: "moderate",
+    executionMode: "loop",
+    headroomModel: "",
+    onboarded: false,
 };
 export function configDir() {
     return process.env.MAQ_CONFIG_DIR ?? join(homedir(), ".maqcli");

package/dist/core/init-wizard.js

@@ -92,13 +92,15 @@ async function _runWizard(rl, cwd, summary) {
     console.log("  ─────────────────────────────");
     console.log("");
     /* ── 2. Auto-detect agents ──────────────────────────────────── */
-    const agents = await detectAgents();
-    if (agents.length > 0) {
+    const agents = detectAgents();
+    const installed = agents.filter((a) => a.installed);
+    if (installed.length > 0) {
         console.log("  Detected agents:");
-        for (const agent of agents) {
-            console.log(`    • ${agent}`);
+        for (const agent of installed) {
+            const status = agent.authenticated ? "authenticated" : "installed (logged out)";
+            console.log(`    • ${agent.name} — ${status}`);
         }
-        summary.push(`Detected ${agents.length} agent(s): ${agents.join(", ")}`);
+        summary.push(`Detected ${installed.length} agent(s): ${installed.map((a) => a.name).join(", ")}`);
     }
     else {
         console.log("  No agents detected.");

package/dist/core/launcher.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Guided launcher — the zero-typing entry point. Running `maq` with no
+ * arguments (or `maq start`) lands here instead of a wall of command help.
+ *
+ * Flow (all keypress-driven, no command memorization):
+ *   Megalodon splash
+ *   → Path A: Connect to Mobile   (start daemon, show pairing + 9-digit key)
+ *   → Path B: AI Mode
+ *        (1) Your installed CLIs      → register as $0 workers/master
+ *        (2) Single model API          → allowed, flagged "limited"
+ *        (3) Multi-provider APIs        → 2026 catalog, list-only ($0)
+ *      → auto-pick the EFFICIENT (mid) model → keep auto or set Headroom model
+ *      → Permissions: Full | Moderate (request-box)
+ *      → build Headroom knowledge, generate 9-digit key, open the browser UI
+ *
+ * Pure helpers (auth key, browser command, onboarding apply, splash) are
+ * exported for testing; the interactive shell is a thin wrapper over them.
+ */
+import { type MaqConfig } from "./config-store.js";
+import { getCatalogProvider } from "./providers-catalog.js";
+import { type TieredModel } from "./capabilities.js";
+import { type ProviderRole } from "./onboarding.js";
+/** A user-facing 9-digit pairing/auth key (100000000–999999999). */
+export declare function generateAuthKey(): string;
+/** OS-specific command to open a URL in the default browser. */
+export declare function browserOpenCommand(url: string, platform?: NodeJS.Platform): {
+    cmd: string;
+    args: string[];
+};
+/** Best-effort: open a URL in the default browser (never throws). */
+export declare function openBrowser(url: string): void;
+/** The Megalodon splash. `color=false` yields a plain-text version. */
+export declare function megalodonSplash(color?: boolean): string;
+export interface OnboardingChoices {
+    /** Registered worker/master models (already tiered). */
+    models: TieredModel[];
+    /** Chosen Headroom (efficient) model; null lets applyOnboarding auto-pick. */
+    headroom?: {
+        provider: string;
+        model: string;
+    } | null;
+    /** Whether the Headroom model was auto-picked. */
+    headroomAuto: boolean;
+    permissionMode: "full" | "moderate";
+    /** How each model was sourced, for the knowledge doc. */
+    source: ProviderRole["source"];
+}
+export interface OnboardingResult {
+    config: MaqConfig;
+    knowledgePath: string;
+    headroom: {
+        provider: string;
+        model: string;
+    } | null;
+    authKey: string;
+}
+/**
+ * Persist an onboarding outcome: pick the efficient model if none was chosen,
+ * write config (provider/model/tiers/permission/onboarded) and the Headroom
+ * knowledge doc, and mint a 9-digit key. Pure w.r.t. I/O beyond the config +
+ * knowledge files, so it is directly testable.
+ */
+export declare function applyOnboarding(choices: OnboardingChoices): OnboardingResult;
+/**
+ * Run the guided launcher. Returns 0 on success. In a non-interactive context
+ * (piped stdin), it prints guidance and returns without blocking.
+ */
+export declare function runLauncher(cwd: string): Promise<number>;
+/** For discoverability from `maq --help` / knowledge. */
+export declare const LAUNCHER_PROVIDERS: string[];
+export { getCatalogProvider };

package/dist/core/launcher.js

@@ -0,0 +1,340 @@
+/**
+ * Guided launcher — the zero-typing entry point. Running `maq` with no
+ * arguments (or `maq start`) lands here instead of a wall of command help.
+ *
+ * Flow (all keypress-driven, no command memorization):
+ *   Megalodon splash
+ *   → Path A: Connect to Mobile   (start daemon, show pairing + 9-digit key)
+ *   → Path B: AI Mode
+ *        (1) Your installed CLIs      → register as $0 workers/master
+ *        (2) Single model API          → allowed, flagged "limited"
+ *        (3) Multi-provider APIs        → 2026 catalog, list-only ($0)
+ *      → auto-pick the EFFICIENT (mid) model → keep auto or set Headroom model
+ *      → Permissions: Full | Moderate (request-box)
+ *      → build Headroom knowledge, generate 9-digit key, open the browser UI
+ *
+ * Pure helpers (auth key, browser command, onboarding apply, splash) are
+ * exported for testing; the interactive shell is a thin wrapper over them.
+ */
+import { createInterface } from "node:readline";
+import { spawn } from "node:child_process";
+import { randomInt } from "node:crypto";
+import { loadConfig, saveConfig } from "./config-store.js";
+import { detectAgents } from "./registry.js";
+import { PROVIDER_CATALOG, detectAvailableProviders, getCatalogProvider, } from "./providers-catalog.js";
+import { classifyModel, pickEfficient } from "./capabilities.js";
+import { buildKnowledge, saveKnowledge, roleForModel } from "./onboarding.js";
+/** Preferred lightest master invocation per detected CLI agent ($0 marginal). */
+const CLI_MASTER_HINT = {
+    gemini: "cli:gemini",
+    "claude-code": "cli:claude-code",
+    codex: "cli:codex",
+    opencode: "cli:opencode",
+    "amazon-q": "cli:amazon-q",
+    aider: "cli:aider",
+};
+/* --------------------------- pure, testable ---------------------------- */
+/** A user-facing 9-digit pairing/auth key (100000000–999999999). */
+export function generateAuthKey() {
+    return String(randomInt(100_000_000, 1_000_000_000));
+}
+/** OS-specific command to open a URL in the default browser. */
+export function browserOpenCommand(url, platform = process.platform) {
+    if (platform === "win32")
+        return { cmd: "cmd", args: ["/c", "start", "", url] };
+    if (platform === "darwin")
+        return { cmd: "open", args: [url] };
+    return { cmd: "xdg-open", args: [url] };
+}
+/** Best-effort: open a URL in the default browser (never throws). */
+export function openBrowser(url) {
+    try {
+        const { cmd, args } = browserOpenCommand(url);
+        const child = spawn(cmd, args, { stdio: "ignore", detached: true, windowsHide: true });
+        child.on("error", () => { });
+        child.unref();
+    }
+    catch {
+        /* ignore */
+    }
+}
+const RED = "\x1b[38;5;196m";
+const WHITE = "\x1b[97m";
+const DIM = "\x1b[2m";
+const RST = "\x1b[0m";
+/** The Megalodon splash. `color=false` yields a plain-text version. */
+export function megalodonSplash(color = true) {
+    const r = color ? RED : "";
+    const w = color ? WHITE : "";
+    const d = color ? DIM : "";
+    const x = color ? RST : "";
+    return [
+        "",
+        `${w}                     ,`,
+        `${w}                   ,'|        ${r}▄▄${x}`,
+        `${w}                 ,'  |      ${r}▄█████▄${x}`,
+        `${w}      ${d}~~~~~${x}${w}    ,'    |   ${r}▄█████████▄${x}   ${w}M A Q${x}`,
+        `${w}   ${d}~~${x}${w}        ,'______|${r}████████████▀${x}`,
+        `${r}  ≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈████████▀${x}      ${d}megalodon${x}`,
+        `${w}            \`.      |${r}██████▀${x}`,
+        `${w}              \`.    |${r}████▀${x}`,
+        `${w}                \`.  |${r}▀▀${x}`,
+        `${w}                  \`.|${x}`,
+        "",
+        `${d}   the apex orchestrator — it hunts, it doesn't type.${x}`,
+        "",
+    ].join("\n");
+}
+/**
+ * Persist an onboarding outcome: pick the efficient model if none was chosen,
+ * write config (provider/model/tiers/permission/onboarded) and the Headroom
+ * knowledge doc, and mint a 9-digit key. Pure w.r.t. I/O beyond the config +
+ * knowledge files, so it is directly testable.
+ */
+export function applyOnboarding(choices) {
+    const cfg = loadConfig();
+    // Resolve the Headroom (efficient) model.
+    let headroom = choices.headroom ?? null;
+    if (!headroom) {
+        const picked = pickEfficient(choices.models);
+        headroom = picked ? { provider: picked.model.maqProvider, model: picked.model.id } : null;
+    }
+    if (headroom) {
+        cfg.provider = headroom.provider;
+        cfg.masterModel = headroom.model;
+        cfg.cheapModel = headroom.model;
+        cfg.headroomModel = choices.headroomAuto ? "" : headroom.model;
+        // Reserve the strongest available model for the hard "strong" tier.
+        const heavy = choices.models.filter((m) => m.tier === "heavy")[0];
+        const mid = choices.models.filter((m) => m.tier === "mid")[0];
+        cfg.strongModel = (heavy ?? mid)?.id ?? headroom.model;
+    }
+    cfg.permissionMode = choices.permissionMode;
+    cfg.onboarded = true;
+    saveConfig(cfg);
+    // Build + persist the Headroom knowledge doc.
+    const providers = choices.models.map((m) => {
+        const role = headroom && m.id === headroom.model
+            ? "headroom-master"
+            : m.tier === "light"
+                ? "fan-out"
+                : m.tier === "heavy"
+                    ? "reviewer"
+                    : "worker";
+        return roleForModel(m, role, choices.source);
+    });
+    const knowledge = buildKnowledge({
+        providers,
+        permissionMode: choices.permissionMode,
+        headroomModel: headroom ? { ...headroom, auto: choices.headroomAuto } : null,
+    });
+    const knowledgePath = saveKnowledge(knowledge);
+    return { config: cfg, knowledgePath, headroom, authKey: generateAuthKey() };
+}
+/* ----------------------------- interactive ----------------------------- */
+function ask(rl, q) {
+    return new Promise((resolve) => rl.question(q, (a) => resolve(a.trim())));
+}
+const useColor = () => Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+function line(s = "") {
+    process.stdout.write(s + "\n");
+}
+/**
+ * Run the guided launcher. Returns 0 on success. In a non-interactive context
+ * (piped stdin), it prints guidance and returns without blocking.
+ */
+export async function runLauncher(cwd) {
+    line(megalodonSplash(useColor()));
+    if (!process.stdin.isTTY) {
+        line("maq: guided setup needs an interactive terminal.");
+        line("  • run `maq start` in a real terminal, or");
+        line("  • use commands directly, e.g. `maq run \"<task>\" --target none`  (see `maq --help`).");
+        return 0;
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return await drive(rl, cwd);
+    }
+    finally {
+        rl.close();
+    }
+}
+async function drive(rl, cwd) {
+    line("How do you want to start?");
+    line("  [1] Connect to Mobile   — pair your phone as a control surface");
+    line("  [2] AI Mode             — set up the intelligence layer");
+    line("  [0] Exit to command help");
+    const path = (await ask(rl, "\n> ")) || "2";
+    if (path === "0")
+        return 1;
+    if (path === "1")
+        return await connectMobile(rl);
+    return await aiMode(rl, cwd);
+}
+async function aiMode(rl, cwd) {
+    line("");
+    line("AI Mode — choose your intelligence source:");
+    line("  [1] Your installed AI CLIs   — $0, reuses your existing subscriptions");
+    line("  [2] A single model API        — one provider/model (limited: no fan-out)");
+    line("  [3] Multi-provider APIs        — the 2026 catalog, pay only when used");
+    const choice = (await ask(rl, "\n> ")) || "1";
+    let models = [];
+    let source = "api";
+    if (choice === "1") {
+        ({ models, source } = await registerClis(rl));
+    }
+    else if (choice === "2") {
+        ({ models, source } = await registerSingleApi(rl));
+    }
+    else {
+        ({ models, source } = await registerMultiApi(rl));
+    }
+    if (models.length === 0) {
+        line("\nNothing registered. Falling back to the offline heuristic master ($0).");
+        models = [{ id: "heuristic-local", provider: "heuristic", maqProvider: "heuristic", tier: "mid" }];
+        source = "local";
+    }
+    // Efficient-mid auto pick, then let the user confirm or override.
+    const picked = pickEfficient(models);
+    let headroom = null;
+    let headroomAuto = true;
+    if (picked) {
+        line(`\nAuto-picked the efficient model: ${picked.model.id}  (${picked.note})`);
+        const keep = (await ask(rl, "Keep this as the Headroom model? [Y/n or number to choose] ")).toLowerCase();
+        if (keep === "" || keep === "y" || keep === "yes") {
+            headroom = { provider: picked.model.maqProvider, model: picked.model.id };
+        }
+        else {
+            models.forEach((m, i) => line(`  [${i + 1}] ${m.id}  (${m.tier})`));
+            const pick = Number(await ask(rl, "Choose a model number: "));
+            const chosen = models[pick - 1] ?? picked.model;
+            headroom = { provider: chosen.maqProvider, model: chosen.id };
+            headroomAuto = false;
+        }
+    }
+    // Permissions.
+    line("");
+    line("Permissions:");
+    line("  [1] Full     — the master (and its workers) may act without stopping");
+    line("  [2] Moderate — major/destructive actions queue to a request-box for approval");
+    const perm = (await ask(rl, "\n> ")) || "2";
+    const permissionMode = perm === "1" ? "full" : "moderate";
+    const result = applyOnboarding({ models, headroom, headroomAuto, permissionMode, source });
+    line("");
+    line("─────────────────────────────────────────────");
+    line(`  Headroom model : ${result.headroom?.model ?? "heuristic-local"} (${headroomAuto ? "auto" : "manual"})`);
+    line(`  Permissions    : ${permissionMode}`);
+    line(`  Knowledge doc  : ${result.knowledgePath}`);
+    line(`  Auth key       : ${result.authKey}`);
+    line("─────────────────────────────────────────────");
+    const open = (await ask(rl, "\nLaunch the browser UI now? [Y/n] ")).toLowerCase();
+    if (open === "" || open === "y" || open === "yes") {
+        return await launchUi(result.authKey);
+    }
+    line("\nReady. Start anytime with:  maq serve   (then open the printed URL)");
+    return 0;
+}
+async function registerClis(rl) {
+    const agents = detectAgents();
+    const ready = agents.filter((a) => a.installed && a.authenticated);
+    if (ready.length === 0) {
+        line("\nNo authenticated AI CLI found. Install/log in to one (claude, codex, gemini, …),");
+        line("or pick option 3 (API providers). Continuing with none for now.");
+        return { models: [], source: "cli" };
+    }
+    line("\nFound these authenticated CLIs (registered as $0 workers):");
+    const models = [];
+    for (const a of ready) {
+        const masterModel = CLI_MASTER_HINT[a.name] ?? `cli:${a.name}`;
+        // A CLI reused as a master is treated as a mid-tier worker for tiering.
+        models.push({ id: masterModel, provider: a.name, maqProvider: masterModel, tier: "mid" });
+        line(`  • ${a.name}  → ${masterModel}`);
+    }
+    line(`\n(To register each CLI's own model list, MAQ will ask it "/models" on first use.)`);
+    return { models, source: "cli" };
+}
+async function registerSingleApi(rl) {
+    const available = detectAvailableProviders().filter((p) => p.active && !p.provider.local);
+    if (available.length === 0) {
+        line("\nNo API keys detected in your environment. Set one (e.g. OPENAI_API_KEY) and re-run,");
+        line("or pick option 1 (your CLIs). Continuing with none for now.");
+        return { models: [], source: "api" };
+    }
+    line("\nActive API providers:");
+    available.forEach((p, i) => line(`  [${i + 1}] ${p.provider.label}`));
+    const pick = Number(await ask(rl, "Choose a provider: ")) || 1;
+    const chosen = (available[pick - 1] ?? available[0]).provider;
+    chosen.models.forEach((m, i) => line(`  [${i + 1}] ${m.id}  (${m.tier})`));
+    const mpick = Number(await ask(rl, "Choose a model: ")) || 1;
+    const model = chosen.models[mpick - 1] ?? chosen.models[0];
+    line("\nNote: a single model can't fan out — parallel/safe modes are disabled until you add more.");
+    return {
+        models: [{ id: model.id, provider: chosen.id, maqProvider: chosen.maqProvider, tier: model.tier }],
+        source: "api",
+    };
+}
+async function registerMultiApi(rl) {
+    const detected = detectAvailableProviders();
+    line("\n2026 provider catalog (● active, ○ actionable — listing is free):");
+    for (const d of detected) {
+        const mark = d.active ? "●" : "○";
+        line(`  ${mark} ${d.provider.label.padEnd(38)} ${d.reason}`);
+        line(`     ${d.provider.setup}`);
+    }
+    const active = detected.filter((d) => d.active);
+    if (active.length === 0) {
+        line("\nNone active yet. Set an API key from the list above, then re-run `maq start`.");
+        return { models: [], source: "api" };
+    }
+    // Register every model of every active provider (available, not consuming tokens).
+    const models = active.flatMap((d) => d.provider.models.map((m) => ({
+        id: m.id,
+        provider: d.provider.id,
+        maqProvider: d.provider.maqProvider,
+        tier: m.tier ?? classifyModel(m.id),
+    })));
+    line(`\nRegistered ${models.length} models across ${active.length} active provider(s).`);
+    return { models, source: "api" };
+}
+async function connectMobile(rl) {
+    const authKey = generateAuthKey();
+    line("\nConnect to Mobile");
+    line("  1. On this machine, MAQ will run its daemon (loopback + a tunnel/tailnet for remote).");
+    line("  2. In the MAQ phone app, pair using the details below.");
+    line("");
+    line(`  Auth key (pairing PIN): ${authKey}`);
+    line("");
+    line("Starting the daemon now with:  maq serve");
+    line("  (the app pairs with host/port + the token the daemon prints)");
+    await ask(rl, "\nPress Enter to continue…");
+    return 0;
+}
+async function launchUi(authKey) {
+    // Reuse the daemon; open its landing page. Import lazily to avoid a cycle.
+    const { createDaemon } = await import("../server/daemon.js");
+    const daemon = createDaemon({ token: authKey, version: "0.4.0" });
+    try {
+        const { host, port } = await daemon.listen();
+        const url = `http://${host}:${port}/`;
+        line(`\nmaq daemon listening on ${url}`);
+        line(`auth key/token: ${authKey}`);
+        openBrowser(url);
+        line("Opened your browser. Press Ctrl-C here to stop the daemon.");
+        await new Promise((resolve) => {
+            const stop = () => {
+                line("\nshutting down…");
+                daemon.close().then(resolve);
+            };
+            process.on("SIGINT", stop);
+            process.on("SIGTERM", stop);
+        });
+        return 0;
+    }
+    catch (e) {
+        line(`could not start daemon: ${e.message}`);
+        return 1;
+    }
+}
+/** For discoverability from `maq --help` / knowledge. */
+export const LAUNCHER_PROVIDERS = PROVIDER_CATALOG.map((p) => p.id);
+export { getCatalogProvider };