maqcli 0.2.0 → 0.5.0

package/dist/core/providers-catalog.js

@@ -0,0 +1,206 @@
+/**
+ * Provider catalog — the 2026 "menu" the guided launcher shows for AI mode
+ * option (3): every kind of AI API provider, its setup format, docs link, and
+ * a known model list. Listing is FREE — it consumes zero tokens and makes zero
+ * network calls. A provider only becomes "active" the moment a task actually
+ * uses it.
+ *
+ * This is deliberately static + dependency-free: it is the vocabulary the
+ * launcher and Headroom knowledge doc are built from. Model lists are the
+ * publicly-known families as of 2026-07; the live `/models`-style discovery for
+ * a specific key is a separate, opt-in step (see capabilities.ts).
+ */
+/**
+ * The registry. Ordered roughly by how commonly it is the user's daily driver.
+ * Model ids are the well-known 2026 families; keep them representative rather
+ * than exhaustive — the point is a browsable, $0 menu.
+ */
+export const PROVIDER_CATALOG = [
+    {
+        id: "openai",
+        label: "OpenAI",
+        format: "openai",
+        maqProvider: "openai",
+        envVar: "OPENAI_API_KEY",
+        baseUrl: "https://api.openai.com/v1",
+        docsUrl: "https://platform.openai.com/api-keys",
+        setup: "export OPENAI_API_KEY=sk-...   (optional OPENAI_BASE_URL)",
+        models: [
+            { id: "gpt-4o-mini", tier: "light", vision: true },
+            { id: "gpt-4.1-mini", tier: "mid", vision: true, longContext: true },
+            { id: "gpt-4o", tier: "mid", vision: true },
+            { id: "gpt-4.1", tier: "heavy", vision: true, longContext: true },
+            { id: "o4-mini", tier: "mid" },
+            { id: "o3", tier: "heavy", longContext: true },
+        ],
+    },
+    {
+        id: "anthropic",
+        label: "Anthropic (Claude)",
+        format: "anthropic",
+        maqProvider: "anthropic",
+        envVar: "ANTHROPIC_API_KEY",
+        baseUrl: "https://api.anthropic.com/v1",
+        docsUrl: "https://console.anthropic.com/settings/keys",
+        setup: "export ANTHROPIC_API_KEY=sk-ant-...",
+        models: [
+            { id: "claude-3-5-haiku-latest", tier: "light" },
+            { id: "claude-3-7-sonnet-latest", tier: "mid", vision: true, longContext: true },
+            { id: "claude-sonnet-4-latest", tier: "mid", vision: true, longContext: true },
+            { id: "claude-opus-4-latest", tier: "heavy", vision: true, longContext: true },
+        ],
+    },
+    {
+        id: "gemini",
+        label: "Google Gemini",
+        format: "gemini",
+        // Reached via an OpenAI-compatible proxy in MAQ today.
+        maqProvider: "openai-compatible",
+        envVar: "GEMINI_API_KEY",
+        baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai",
+        docsUrl: "https://aistudio.google.com/apikey",
+        setup: "export GEMINI_API_KEY=...   (OpenAI-compatible endpoint; set MAQ_PROVIDER_BASE_URL)",
+        models: [
+            { id: "gemini-2.0-flash", tier: "light", vision: true, longContext: true },
+            { id: "gemini-2.5-flash", tier: "mid", vision: true, longContext: true },
+            { id: "gemini-2.5-pro", tier: "heavy", vision: true, longContext: true },
+        ],
+    },
+    {
+        id: "groq",
+        label: "Groq (fast inference)",
+        format: "openai",
+        maqProvider: "groq",
+        envVar: "GROQ_API_KEY",
+        baseUrl: "https://api.groq.com/openai/v1",
+        docsUrl: "https://console.groq.com/keys",
+        setup: "export GROQ_API_KEY=gsk_...   (free tier available)",
+        models: [
+            { id: "llama-3.1-8b-instant", tier: "light" },
+            { id: "llama-3.3-70b-versatile", tier: "mid" },
+            { id: "deepseek-r1-distill-llama-70b", tier: "heavy" },
+        ],
+    },
+    {
+        id: "xai",
+        label: "xAI (Grok)",
+        format: "openai",
+        maqProvider: "openai-compatible",
+        envVar: "XAI_API_KEY",
+        baseUrl: "https://api.x.ai/v1",
+        docsUrl: "https://console.x.ai",
+        setup: "export XAI_API_KEY=...   (set MAQ_PROVIDER_BASE_URL=https://api.x.ai/v1)",
+        models: [
+            { id: "grok-3-mini", tier: "mid" },
+            { id: "grok-4", tier: "heavy", vision: true, longContext: true },
+        ],
+    },
+    {
+        id: "deepseek",
+        label: "DeepSeek",
+        format: "openai",
+        maqProvider: "openai-compatible",
+        envVar: "DEEPSEEK_API_KEY",
+        baseUrl: "https://api.deepseek.com/v1",
+        docsUrl: "https://platform.deepseek.com/api_keys",
+        setup: "export DEEPSEEK_API_KEY=...   (set MAQ_PROVIDER_BASE_URL=https://api.deepseek.com/v1)",
+        models: [
+            { id: "deepseek-chat", tier: "mid", longContext: true },
+            { id: "deepseek-reasoner", tier: "heavy", longContext: true },
+        ],
+    },
+    {
+        id: "mistral",
+        label: "Mistral",
+        format: "openai",
+        maqProvider: "openai-compatible",
+        envVar: "MISTRAL_API_KEY",
+        baseUrl: "https://api.mistral.ai/v1",
+        docsUrl: "https://console.mistral.ai/api-keys",
+        setup: "export MISTRAL_API_KEY=...   (set MAQ_PROVIDER_BASE_URL=https://api.mistral.ai/v1)",
+        models: [
+            { id: "mistral-small-latest", tier: "light" },
+            { id: "mistral-medium-latest", tier: "mid", longContext: true },
+            { id: "mistral-large-latest", tier: "heavy", longContext: true },
+        ],
+    },
+    {
+        id: "ollama",
+        label: "Ollama (local, $0)",
+        format: "ollama",
+        maqProvider: "ollama",
+        envVar: "",
+        baseUrl: "http://127.0.0.1:11434",
+        docsUrl: "https://ollama.com/library",
+        local: true,
+        setup: "run Ollama locally; optional OLLAMA_HOST",
+        models: [
+            { id: "llama3.2", tier: "light" },
+            { id: "llama3.1", tier: "mid", longContext: true },
+            { id: "qwen2.5-coder", tier: "mid" },
+            { id: "deepseek-r1", tier: "heavy" },
+        ],
+    },
+    {
+        id: "litellm",
+        label: "LiteLLM / any OpenAI-compatible proxy",
+        format: "openai",
+        maqProvider: "openai-compatible",
+        envVar: "MAQ_PROVIDER_API_KEY",
+        baseUrl: "http://127.0.0.1:4000",
+        docsUrl: "https://docs.litellm.ai/docs/simple_proxy",
+        setup: "point MAQ_PROVIDER_BASE_URL at your proxy (+ MAQ_PROVIDER_API_KEY)",
+        models: [{ id: "proxy-routed", tier: "mid" }],
+    },
+];
+export function getCatalogProvider(id) {
+    return PROVIDER_CATALOG.find((p) => p.id === id);
+}
+/**
+ * The role each provider tends to play in the pipeline (fed into the Headroom
+ * knowledge doc). Roles: plan | code | review | summarize | fan-out.
+ */
+const PROVIDER_GOOD_FOR = {
+    openai: ["plan", "code", "review"],
+    anthropic: ["plan", "code", "review", "summarize"],
+    gemini: ["summarize", "code", "fan-out"],
+    groq: ["fan-out", "summarize"],
+    xai: ["plan", "code"],
+    deepseek: ["code", "review"],
+    mistral: ["code", "summarize"],
+    ollama: ["fan-out", "summarize"],
+    litellm: ["plan", "code", "review"],
+};
+export function providerGoodFor(id) {
+    return PROVIDER_GOOD_FOR[id] ?? ["code"];
+}
+/**
+ * Detect which catalog providers are usable RIGHT NOW from the environment
+ * only — no network, no tokens. Local providers (Ollama) are reported as
+ * "actionable" (installed/reachable is confirmed later, on first use).
+ */
+export function detectAvailableProviders(env = process.env) {
+    return PROVIDER_CATALOG.map((provider) => {
+        if (provider.local) {
+            return { provider, active: Boolean(env.OLLAMA_HOST) || true, reason: "local runtime (verified on first use)" };
+        }
+        const hasKey = provider.envVar ? Boolean(env[provider.envVar]) : false;
+        // openai-compatible providers also need a base URL configured in MAQ.
+        const needsBaseUrl = provider.maqProvider === "openai-compatible";
+        const hasBaseUrl = Boolean(env.MAQ_PROVIDER_BASE_URL);
+        const active = hasKey && (!needsBaseUrl || hasBaseUrl);
+        return {
+            provider,
+            active,
+            reason: hasKey
+                ? needsBaseUrl && !hasBaseUrl
+                    ? `${provider.envVar} set; also set MAQ_PROVIDER_BASE_URL=${provider.baseUrl}`
+                    : `${provider.envVar} present`
+                : `set ${provider.envVar} to activate`,
+        };
+    });
+}
+/** Flat list of every catalog model tagged with its provider (for tiering). */
+export function allCatalogModels() {
+    return PROVIDER_CATALOG.flatMap((p) => p.models.map((m) => ({ ...m, provider: p.id, maqProvider: p.maqProvider })));
+}

package/dist/core/session.d.ts

@@ -15,6 +15,7 @@
  * events, never a raw shared transcript.
  */
 import type { MaqEvent, PipelineResult } from "./types.js";
+import { type ExecutionMode, type OrchestrationResult } from "./orchestrator.js";
 export type SessionStatus = "running" | "paused" | "cancelled" | "done" | "error";
 export interface InboxMessage {
     ts: string;
@@ -29,9 +30,11 @@ export interface Session {
     cwd: string;
     createdAt: string;
     updatedAt: string;
+    mode?: ExecutionMode;
     events: MaqEvent[];
     inbox: InboxMessage[];
     result?: PipelineResult;
+    orchestration?: OrchestrationResult;
     error?: string;
 }
 export interface SessionSummary {
@@ -44,6 +47,7 @@ export interface SessionSummary {
     updatedAt: string;
     verified?: boolean;
     eventCount: number;
+    mode?: ExecutionMode;
 }
 export interface CreateOptions {
     cwd?: string;
@@ -56,6 +60,14 @@ export interface CreateOptions {
     provider?: string;
     /** Model override (else config tier models). */
     model?: string;
+    /** Execution engine: when set, run the orchestrator instead of one pipeline. */
+    mode?: ExecutionMode;
+    /** Orchestration tuning. */
+    maxRounds?: number;
+    maxIterations?: number;
+    maxConcurrency?: number;
+    /** Permission gate for major orchestration steps (moderate mode). */
+    requestPermission?: (action: string, detail: string, risk: "low" | "major" | "destructive") => Promise<boolean>;
 }
 type Listener = (e: MaqEvent) => void;
 /** Thrown through the pipeline checkpoint when a session is cancelled. */

package/dist/core/session.js

@@ -18,6 +18,7 @@ import { EventEmitter } from "node:events";
 import { randomUUID } from "node:crypto";
 import { makeEvent } from "./types.js";
 import { runPipeline } from "./pipeline.js";
+import { runOrchestration } from "./orchestrator.js";
 import { ProfileManager } from "./profiles.js";
 /** Thrown through the pipeline checkpoint when a session is cancelled. */
 export class CancelError extends Error {
@@ -73,8 +74,9 @@ export class SessionRegistry {
             cwd: s.cwd,
             createdAt: s.createdAt,
             updatedAt: s.updatedAt,
-            verified: s.result?.verify.verified,
+            verified: s.orchestration ? s.orchestration.verified : s.result?.verify.verified,
             eventCount: s.events.length,
+            mode: s.mode,
         };
     }
     /** Subscribe to live events for a session. Returns an unsubscribe fn. */
@@ -126,6 +128,7 @@ export class SessionRegistry {
             cwd: opts.cwd ?? process.cwd(),
             createdAt: now,
             updatedAt: now,
+            mode: opts.mode,
             events: [],
             inbox: [],
         };
@@ -142,28 +145,50 @@ export class SessionRegistry {
                 c.resumeWaiters.push(() => (this.controls.get(id)?.cancelled ? reject(new CancelError()) : resolve()));
             });
         };
-        const pipelineOpts = {
-            cwd: session.cwd,
-            target,
-            provider,
-            model,
-            dryRun: opts.dryRun,
-            timeoutMs: opts.timeoutMs,
-            onEvent: (e) => this.push(session, e),
-            signal: control.abort.signal,
-            checkpoint,
-        };
-        // Run asynchronously; never throw out of assign/handoff spawn.
-        runPipeline(task, pipelineOpts)
-            .then((result) => {
-            if (session.status === "cancelled")
-                return;
-            session.result = result;
-            session.status = "done";
-            session.updatedAt = new Date().toISOString();
-            this.bus.emit(`done:${id}`);
-        })
-            .catch((err) => {
+        const onEvent = (e) => this.push(session, e);
+        // Choose the runner: a single pipeline, or one of the orchestration engines.
+        const run = opts.mode
+            ? runOrchestration(task, opts.mode, {
+                cwd: session.cwd,
+                target,
+                provider,
+                model,
+                dryRun: opts.dryRun,
+                maxRounds: opts.maxRounds,
+                maxIterations: opts.maxIterations,
+                maxConcurrency: opts.maxConcurrency,
+                onEvent,
+                signal: control.abort.signal,
+                checkpoint,
+                requestPermission: opts.requestPermission,
+            }).then((orchestration) => {
+                if (session.status === "cancelled")
+                    return;
+                session.orchestration = orchestration;
+                session.status = "done";
+                session.updatedAt = new Date().toISOString();
+                this.bus.emit(`done:${id}`);
+            })
+            : runPipeline(task, {
+                cwd: session.cwd,
+                target,
+                provider,
+                model,
+                dryRun: opts.dryRun,
+                timeoutMs: opts.timeoutMs,
+                onEvent,
+                signal: control.abort.signal,
+                checkpoint,
+            }).then((result) => {
+                if (session.status === "cancelled")
+                    return;
+                session.result = result;
+                session.status = "done";
+                session.updatedAt = new Date().toISOString();
+                this.bus.emit(`done:${id}`);
+            });
+        // Never throw out of assign/handoff spawn.
+        run.catch((err) => {
             if (err instanceof CancelError || this.controls.get(id)?.cancelled) {
                 session.status = "cancelled";
                 session.updatedAt = new Date().toISOString();

package/dist/index.js

@@ -41,11 +41,17 @@ import { getTopic, listTopics, renderTopic } from "./core/help-topics.js";
 import { generateCompletion, detectShell } from "./core/completion.js";
 import { runInit } from "./core/init-wizard.js";
 import { CostTracker } from "./core/cost-tracker.js";
-const VERSION = "0.2.0";
+import { runLauncher } from "./core/launcher.js";
+import { runOrchestration } from "./core/orchestrator.js";
+const VERSION = "0.5.0";
 async function main(argv) {
     const [command, ...rest] = argv;
     switch (command) {
         case undefined:
+            // Zero typing: no args launches the guided experience.
+            return runLauncher(rest[0] ?? process.cwd());
+        case "start":
+            return runLauncher(process.cwd());
         case "-h":
         case "--help":
             printHelp();
@@ -67,6 +73,8 @@ async function main(argv) {
             return cmdPlan(rest);
         case "run":
             return cmdRun(rest);
+        case "orchestrate":
+            return cmdOrchestrate(rest);
         case "verify":
             return cmdVerify(rest);
         case "serve":
@@ -253,6 +261,55 @@ async function cmdRun(args) {
     }
     return result.verify.verified && result.execute.status !== "failed" ? 0 : 3;
 }
+async function cmdOrchestrate(args) {
+    const { values, positionals } = parseArgs({
+        args,
+        options: {
+            ...commonFlags(),
+            mode: { type: "string", short: "m" },
+            target: { type: "string", short: "t" },
+            provider: { type: "string" },
+            model: { type: "string" },
+            "dry-run": { type: "boolean", default: false },
+            concurrency: { type: "string" },
+            "max-rounds": { type: "string" },
+            "max-iterations": { type: "string" },
+        },
+        allowPositionals: true,
+    });
+    const goal = positionals.join(" ").trim();
+    const mode = values.mode ?? "parallel";
+    if (!goal || !["parallel", "loop", "safe"].includes(mode)) {
+        logger.error('usage: maq orchestrate "<goal>" --mode parallel|loop|safe [--target t] [--concurrency N] [--max-rounds N] [--max-iterations N] [--dry-run] [--json]');
+        return 1;
+    }
+    const streamJson = values.json;
+    const result = await runOrchestration(goal, mode, {
+        cwd: values.cwd ?? process.cwd(),
+        target: values.target,
+        provider: values.provider,
+        model: values.model,
+        dryRun: values["dry-run"],
+        maxConcurrency: values.concurrency ? Number(values.concurrency) : undefined,
+        maxRounds: values["max-rounds"] ? Number(values["max-rounds"]) : undefined,
+        maxIterations: values["max-iterations"] ? Number(values["max-iterations"]) : undefined,
+        onEvent: (e) => {
+            if (streamJson)
+                logger.out(JSON.stringify(e));
+            else
+                renderEvent(e);
+        },
+    });
+    if (streamJson) {
+        logger.out(JSON.stringify(result));
+    }
+    else {
+        logger.out("");
+        logger.out(`orchestration [${result.mode}] ${result.verified ? "VERIFIED" : "unverified"} in ${result.rounds} round(s), ${result.subtasks.length} sub-task(s)`);
+        logger.out(`  ${result.summary}`);
+    }
+    return result.verified ? 0 : 3;
+}
 async function cmdVerify(args) {
     const { values } = parseArgs({ args, options: commonFlags(), allowPositionals: true });
     const cwd = values.cwd ?? process.cwd();
@@ -982,11 +1039,15 @@ function printHelp() {
         "",
         "Usage: maq <command> [options]",
         "",
+        "  (run `maq` with no arguments for the guided, zero-typing launcher)",
+        "",
         "Commands:",
+        "  start                        Guided launcher: pick mobile/AI mode, models, permissions",
         "  detect                       Scan PATH + auth dirs for worker CLIs",
         '  scout "<task>"               Read-only recon; prints structured findings',
         '  plan "<task>"                Verifier-gated candidate plan (scout + plan)',
         '  run "<task>" [opts]          Full pipeline; dispatch to a worker or raw',
+        '  orchestrate "<goal>" -m MODE Run the parallel|loop|safe execution engine over a goal',
         "  verify [--cwd <dir>]         Run project tests / cross-model review",
         "  serve [--host --port --token] Start the HTTP+SSE daemon (app seam)",
         "  sessions [<id>] [pause|resume|cancel]  List/inspect/control daemon sessions (needs MAQ_TOKEN)",

package/dist/server/daemon.js

@@ -33,6 +33,9 @@ import { probeConnectivity } from "../core/probe.js";
 import { execSafe } from "../core/exec.js";
 import { commandCatalog, maqCommands } from "../core/command-catalog.js";
 import { InteractiveRegistry } from "../core/interactive-registry.js";
+import { webuiHtml } from "./webui.js";
+import { PermissionBroker } from "../core/permissions.js";
+import { loadConfig } from "../core/config-store.js";
 /** Generate a URL-safe token. */
 export function generateToken() {
     return randomBytes(24).toString("base64url");
@@ -48,11 +51,17 @@ export function createDaemon(opts = {}) {
     const host = opts.host ?? process.env.MAQ_HOST ?? "127.0.0.1";
     const port = opts.port ?? Number(process.env.MAQ_PORT ?? 7717);
     const token = opts.token ?? process.env.MAQ_TOKEN ?? generateToken();
-    const version = opts.version ?? "0.2.0";
+    const version = opts.version ?? "0.5.0";
     const corsOrigin = opts.corsOrigin ?? process.env.MAQ_CORS_ORIGIN;
     const registry = opts.registry ?? new SessionRegistry();
     const interactive = new InteractiveRegistry();
     const startedAt = Date.now();
+    // The request-box. Posture comes from config (set by the guided launcher).
+    const permissionMode = (() => {
+        const m = loadConfig().permissionMode;
+        return m === "full" ? "full" : "moderate";
+    })();
+    const broker = new PermissionBroker(permissionMode);
     // Track live SSE responses so shutdown can end them deterministically.
     // Without this, server.close() blocks forever on the long-lived event
     // streams (they only emit a keep-alive ping every 15s and never end on their
@@ -87,6 +96,13 @@ export function createDaemon(opts = {}) {
             res.end();
             return;
         }
+        // The god-level control UI (no auth for the HTML shell; API calls it makes
+        // carry the Bearer token). Served at / and /app.
+        if ((path === "/" || path === "/app") && method === "GET") {
+            res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+            res.end(webuiHtml(version));
+            return;
+        }
         // Liveness needs no auth.
         if (path === "/health" && method === "GET") {
             sendJson(res, 200, {
@@ -115,6 +131,28 @@ export function createDaemon(opts = {}) {
             sendJson(res, 200, commandCatalog());
             return;
         }
+        // The permission request-box.
+        if (path === "/v1/requests" && method === "GET") {
+            sendJson(res, 200, { mode: broker.getMode(), pending: broker.pending(), requests: broker.list() });
+            return;
+        }
+        const reqMatch = /^\/v1\/requests\/([^/]+)$/.exec(path);
+        if (reqMatch && method === "POST") {
+            const id = decodeURIComponent(reqMatch[1]);
+            const body = await readJson(req);
+            const action = String(body.action ?? "");
+            let ok = false;
+            if (action === "approve")
+                ok = broker.approve(id, "web");
+            else if (action === "deny")
+                ok = broker.deny(id, "web");
+            else {
+                sendJson(res, 400, { error: "action must be approve|deny" });
+                return;
+            }
+            sendJson(res, ok ? 202 : 409, { id, action, ok, request: broker.get(id) });
+            return;
+        }
         // Whitelisted CLI runner — powers the app's Master (terminal) edition.
         // Only known `maq` subcommands run; never arbitrary shell.
         if (path === "/v1/exec" && method === "POST") {
@@ -197,6 +235,13 @@ export function createDaemon(opts = {}) {
                 cwd: typeof body.cwd === "string" ? body.cwd : undefined,
                 dryRun: Boolean(body.dryRun),
                 timeoutMs: typeof body.timeoutMs === "number" ? body.timeoutMs : undefined,
+                mode: body.mode === "parallel" || body.mode === "loop" || body.mode === "safe" ? body.mode : undefined,
+                maxRounds: typeof body.maxRounds === "number" ? body.maxRounds : undefined,
+                maxIterations: typeof body.maxIterations === "number" ? body.maxIterations : undefined,
+                maxConcurrency: typeof body.maxConcurrency === "number" ? body.maxConcurrency : undefined,
+                // Major orchestration steps pass through the request-box, judged
+                // against this session's goal.
+                requestPermission: (action, detail, risk) => broker.gate(action, detail, { risk, goal: task }),
             });
             sendJson(res, 201, registry.summarize(s));
             return;

package/dist/server/relay-bridge.js

@@ -111,6 +111,10 @@ export class RelayBridge {
                     target: typeof op.target === "string" ? op.target : undefined,
                     cwd: typeof op.cwd === "string" ? op.cwd : undefined,
                     dryRun: Boolean(op.dryRun),
+                    mode: op.mode === "parallel" || op.mode === "loop" || op.mode === "safe" ? op.mode : undefined,
+                    maxRounds: typeof op.maxRounds === "number" ? op.maxRounds : undefined,
+                    maxIterations: typeof op.maxIterations === "number" ? op.maxIterations : undefined,
+                    maxConcurrency: typeof op.maxConcurrency === "number" ? op.maxConcurrency : undefined,
                 });
                 this.reply({ kind: "created", session: reg.summarize(s), reqId });
                 this.subscribe(s.id);

package/dist/server/webui.d.ts

@@ -0,0 +1,19 @@
+/**
+ * webui.ts — the self-contained "god-level" control UI the daemon serves at
+ * `/app` (and `/`). Zero build step, zero dependencies: one HTML document with
+ * inline CSS + vanilla JS. It renders the SAME normalized event stream the
+ * mobile app consumes, so there is no second source of truth.
+ *
+ * Layout (Cursor-style, megalodon theme — deep black + electric blue + white):
+ *   ┌ left ────────────┬ center ───────────────────────┬ right (collapsible) ┐
+ *   │ sessions/agents/ │ goal input + mode toggle       │ preview: session    │
+ *   │ history          │ (parallel|loop|safe) + send    │ detail / result     │
+ *   │                  │ phase chips + live SSE console │ JSON                 │
+ *   └──────────────────┴────────────────────────────────┴──────────────────────┘
+ * A feature switcher (top bar) runs detect / doctor / connectivity / models.
+ *
+ * Auth: the daemon requires a Bearer token for /v1/* . The page reads it from
+ * ?token=… or a prompt, keeps it in memory only, and streams SSE via fetch +
+ * ReadableStream (so the token rides in the Authorization header, never the URL).
+ */
+export declare function webuiHtml(version: string): string;