@backburner/cli 0.1.0 → 0.1.1

package/README.md

@@ -117,12 +117,14 @@ Useful `init` flags:
 --yes, -y                Accept defaults without prompts
 ```
 
-`backburner init` checks local requirements, confirms `gh auth status`, discovers repositories, detects provider CLIs, and writes these files into the management directory:
+`backburner init` checks local requirements, confirms `gh auth status`, discovers repositories, detects provider CLIs, attempts model-list discovery when supported by those CLIs, and writes these files into the management directory:
 
 - `repos.json`
 - `agents.json`
 
-If either file already exists, onboarding asks before overwriting it. With `--yes`, defaults are accepted non-interactively.
+If either file already exists, onboarding asks before overwriting it. With `--yes`, defaults are accepted non-interactively, including selecting existing discovered repositories, enabling every discovered provider, and creating strong and cheap agents for each one. `--yes` does not create a private demo repository.
+
+Repository setup first asks whether to select existing repositories, create a private Backburner demo repository, or skip repository setup for now. In an interactive terminal, repository and provider selection use a checkbox picker: arrow keys move, space toggles, and enter confirms. Non-TTY sessions fall back to text input and accept comma-separated numbers. If you are authenticated with GitHub but do not want to onboard an existing local clone yet, onboarding can explicitly create a private `backburner-demo` repository and clone it under the configured code root.
 
 ## Default Directories
 
@@ -180,7 +182,7 @@ Minimal `agents.json`:
       "id": "codex-strong",
       "provider": "codex",
       "modelClass": "strong",
-      "model": "gpt-5",
+      "model": "sol",
       "roles": [
         "product",
         "planning",
@@ -192,15 +194,15 @@ Minimal `agents.json`:
       "enabled": true
     },
     {
-      "id": "opencode-cheap",
-      "provider": "opencode",
+      "id": "codex-cheap",
+      "provider": "codex",
       "modelClass": "cheap",
-      "model": "your-fast-model",
+      "model": "luna",
       "roles": [
         "implementation",
         "discussion"
       ],
-      "command": "opencode",
+      "command": "codex",
       "enabled": true
     }
   ]
@@ -209,7 +211,7 @@ Minimal `agents.json`:
 
 `allowedUsers` limits which GitHub users can feed issues, comments, reviews, and pull requests into task derivation. `localPath` must be relative to `--code-root`.
 
-Agent selection filters enabled agents by required role and `modelClass`, then breaks ties by lowest agent `id`. Provider model names are passed through to the provider CLI and are not validated against vendor catalogs.
+Agent selection filters enabled agents by required role and `modelClass`, then breaks ties by lowest agent `id`. Provider model names are passed through to the provider CLI and are not validated against vendor catalogs. During onboarding, model setup shows discovered model options when available, marks strong and cheap defaults, and pressing enter accepts the default. Backburner prefers discovered `sol` for strong, `terra` for balanced/default, and `luna` for cheap model names; Codex defaults are `sol` and `luna`. OpenCode may use discovered OpenRouter model IDs such as `openrouter/openai/gpt-5.6-sol` and `openrouter/openai/gpt-5.6-luna`.
 
 ## Label Control Plane
 

package/dist/src/cli/dispatcher.js

@@ -14,6 +14,10 @@ export async function main(argv = process.argv.slice(2)) {
         process.stdout.write(`${usage}\n`);
         return;
     }
+    if (command !== undefined && hasHelpFlag(rest)) {
+        process.stdout.write(`${usage}\n`);
+        return;
+    }
     if (command === "run") {
         if (shouldUseRuntimeStatusScreen(rest)) {
             await runInteractiveTui([command, ...rest]);
@@ -49,3 +53,6 @@ export async function main(argv = process.argv.slice(2)) {
     }
     throw new CliUsageError(usage);
 }
+function hasHelpFlag(argv) {
+    return argv.includes("--help") || argv.includes("-h");
+}

package/dist/src/cli/init.js

@@ -14,6 +14,7 @@ import { ConfigureModelsStep } from "../onboarding/steps/configure-models.js";
 import { GenerateConfigStep } from "../onboarding/steps/generate-config.js";
 import { ReadinessValidationStep } from "../onboarding/steps/readiness-validation.js";
 import { ShowSummaryStep } from "../onboarding/steps/show-summary.js";
+import { DemoRepoCreator } from "../onboarding/services/demo-repo.js";
 export async function runInitCli(argv) {
     const codeRoot = readStringFlag(argv, "--code-root") ?? defaultBackburnerCodeRoot();
     const managementDir = readStringFlag(argv, "--management-dir");
@@ -56,7 +57,7 @@ export async function runInit(options) {
         new CheckRequirementsStep(commandRunner),
         new CheckGitHubAuthStep(commandRunner),
         new DiscoverReposStep(commandRunner, ctx.codeRoot),
-        new SelectReposStep(),
+        new SelectReposStep(new DemoRepoCreator(commandRunner)),
         new ConfigurePathsStep(),
         new DiscoverProvidersStep(commandRunner),
         new ConfigureModelsStep(),

package/dist/src/onboarding/prompt.js

@@ -1,3 +1,4 @@
+import { emitKeypressEvents } from "node:readline";
 import * as readline from "node:readline/promises";
 /**
  * Interactive prompter backed by Node.js readline/promises.
@@ -5,10 +6,14 @@ import * as readline from "node:readline/promises";
  */
 export class NodeReadlinePrompter {
     rl;
-    constructor() {
+    input;
+    output;
+    constructor(options = {}) {
+        this.input = options.input ?? process.stdin;
+        this.output = options.output ?? process.stdout;
         this.rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout
+            input: this.input,
+            output: this.output
         });
     }
     close() {
@@ -32,7 +37,7 @@ export class NodeReadlinePrompter {
             const marker = i === defaultIndex ? "*" : " ";
             lines.push(`  ${marker} ${i + 1}. ${options[i] ?? ""}`);
         }
-        process.stdout.write(`${lines.join("\n")}\n`);
+        this.output.write(`${lines.join("\n")}\n`);
         const defaultHint = defaultIndex !== undefined ? ` [${defaultIndex + 1}]` : "";
         // eslint-disable-next-line no-constant-condition
         while (true) {
@@ -44,10 +49,16 @@ export class NodeReadlinePrompter {
             if (Number.isInteger(n) && n >= 1 && n <= options.length) {
                 return n - 1;
             }
-            process.stdout.write(`  Please enter a number between 1 and ${options.length}\n`);
+            this.output.write(`  Please enter a number between 1 and ${options.length}\n`);
         }
     }
     async multiSelect(question, options, preSelected) {
+        if (canUseTerminalPicker(this.input, this.output)) {
+            return this.terminalMultiSelect(question, options, preSelected);
+        }
+        return this.textMultiSelect(question, options, preSelected);
+    }
+    async textMultiSelect(question, options, preSelected) {
         const preSet = new Set(preSelected ?? []);
         const lines = [
             question,
@@ -57,30 +68,100 @@ export class NodeReadlinePrompter {
             const marker = preSet.has(i) ? "[x]" : "[ ]";
             lines.push(`  ${marker} ${i + 1}. ${options[i] ?? ""}`);
         }
-        process.stdout.write(`${lines.join("\n")}\n`);
+        this.output.write(`${lines.join("\n")}\n`);
         // eslint-disable-next-line no-constant-condition
         while (true) {
             const answer = (await this.rl.question("Selection: ")).trim().toLowerCase();
-            if (answer === "all")
-                return options.map((_, i) => i);
-            if (answer === "" || answer === "none")
-                return preSelected ?? [];
-            const parts = answer.split(",").map((p) => p.trim());
-            const indices = [];
-            let valid = true;
-            for (const part of parts) {
-                const n = Number(part);
-                if (!Number.isInteger(n) || n < 1 || n > options.length) {
-                    process.stdout.write(`  Invalid selection "${part}". Enter numbers between 1 and ${options.length}\n`);
-                    valid = false;
-                    break;
-                }
-                indices.push(n - 1);
+            const parsed = parseTextMultiSelectAnswer(answer, options.length, preSelected);
+            if (parsed.ok)
+                return parsed.indices;
+            if (parsed.invalidPart !== undefined) {
+                this.output.write(`  Invalid selection "${parsed.invalidPart}". Enter numbers between 1 and ${options.length}\n`);
             }
-            if (valid)
-                return [...new Set(indices)];
         }
     }
+    async terminalMultiSelect(question, options, preSelected) {
+        const selected = new Set(preSelected ?? []);
+        let cursor = preSelected?.[0] ?? 0;
+        if (cursor < 0 || cursor >= options.length)
+            cursor = 0;
+        this.rl.pause();
+        emitKeypressEvents(this.input);
+        this.input.setRawMode?.(true);
+        this.input.resume();
+        return await new Promise((resolve) => {
+            const render = () => {
+                const lines = [
+                    question,
+                    "Use ↑/↓ to move, space to toggle, enter to confirm.",
+                    ...options.map((option, i) => {
+                        const pointer = i === cursor ? ">" : " ";
+                        const marker = selected.has(i) ? "[x]" : "[ ]";
+                        return `${pointer} ${marker} ${option}`;
+                    })
+                ];
+                this.output.write(`\x1b[?25l\x1b[2K\r${lines.join("\n")}`);
+                this.output.write(`\x1b[${lines.length - 1}A`);
+            };
+            const finish = () => {
+                this.input.off("keypress", onKeypress);
+                this.input.setRawMode?.(false);
+                this.output.write(`\x1b[?25h\x1b[${options.length + 1}B\n`);
+                this.rl.resume();
+                resolve([...selected].sort((a, b) => a - b));
+            };
+            const onKeypress = (_chunk, key) => {
+                if (key.ctrl === true && key.name === "c") {
+                    finish();
+                    return;
+                }
+                switch (key.name) {
+                    case "up":
+                        cursor = cursor <= 0 ? options.length - 1 : cursor - 1;
+                        render();
+                        break;
+                    case "down":
+                        cursor = cursor >= options.length - 1 ? 0 : cursor + 1;
+                        render();
+                        break;
+                    case "space":
+                        if (selected.has(cursor)) {
+                            selected.delete(cursor);
+                        }
+                        else {
+                            selected.add(cursor);
+                        }
+                        render();
+                        break;
+                    case "return":
+                    case "enter":
+                        finish();
+                        break;
+                }
+            };
+            this.input.on("keypress", onKeypress);
+            render();
+        });
+    }
+}
+function canUseTerminalPicker(input, output) {
+    return input.isTTY === true && output.isTTY === true && typeof input.setRawMode === "function";
+}
+export function parseTextMultiSelectAnswer(answer, optionCount, preSelected) {
+    if (answer === "all")
+        return { ok: true, indices: Array.from({ length: optionCount }, (_, i) => i) };
+    if (answer === "" || answer === "none")
+        return { ok: true, indices: preSelected ?? [] };
+    const parts = answer.split(",").map((p) => p.trim());
+    const indices = [];
+    for (const part of parts) {
+        const n = Number(part);
+        if (!Number.isInteger(n) || n < 1 || n > optionCount) {
+            return { ok: false, invalidPart: part };
+        }
+        indices.push(n - 1);
+    }
+    return { ok: true, indices: [...new Set(indices)] };
 }
 /**
  * Non-interactive prompter that accepts all defaults.

package/dist/src/onboarding/services/demo-repo.js

@@ -0,0 +1,33 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+export class DemoRepoCreator {
+    commandRunner;
+    constructor(commandRunner) {
+        this.commandRunner = commandRunner;
+    }
+    async createPrivateDemoRepo(options) {
+        await fs.mkdir(options.codeRoot, { recursive: true });
+        await this.commandRunner.run("gh", [
+            "repo",
+            "create",
+            `${options.owner}/${options.name}`,
+            "--private",
+            "--clone",
+            "--add-readme",
+            "--description",
+            "Private Backburner onboarding demo repository"
+        ], { cwd: options.codeRoot, timeoutMs: 60_000 });
+        return {
+            owner: options.owner,
+            name: options.name,
+            localPath: path.join(options.codeRoot, options.name),
+            defaultBranch: "main",
+            isLocalClone: true,
+            canFetch: true,
+            canPush: true
+        };
+    }
+}
+export function defaultDemoRepoName() {
+    return "backburner-demo";
+}

package/dist/src/onboarding/services/provider-discovery.js

@@ -3,31 +3,36 @@ const PROVIDER_SPECS = [
         name: "claude",
         command: "claude",
         versionArgs: ["--version"],
-        versionExtract: (out) => out.trim().split("\n")[0] ?? out.trim()
+        versionExtract: (out) => out.trim().split("\n")[0] ?? out.trim(),
+        modelListCommands: [["models"], ["models", "list"], ["model", "list"]]
     },
     {
         name: "codex",
         command: "codex",
         versionArgs: ["--version"],
-        versionExtract: (out) => out.trim()
+        versionExtract: (out) => out.trim(),
+        modelListCommands: [["models"], ["models", "list"], ["model", "list"]]
     },
     {
         name: "gemini",
         command: "gemini",
         versionArgs: ["--version"],
-        versionExtract: (out) => out.trim()
+        versionExtract: (out) => out.trim(),
+        modelListCommands: [["models"], ["models", "list"], ["model", "list"]]
     },
     {
         name: "opencode",
         command: "opencode",
         versionArgs: ["--version"],
-        versionExtract: (out) => out.trim()
+        versionExtract: (out) => out.trim(),
+        modelListCommands: [["models"], ["models", "list"], ["model", "list"]]
     },
     {
         name: "antigravity",
         command: "agy",
         versionArgs: ["--version"],
-        versionExtract: (out) => out.trim()
+        versionExtract: (out) => out.trim(),
+        modelListCommands: [["models"], ["models", "list"], ["model", "list"]]
     }
 ];
 export class ProviderDiscoveryService {
@@ -44,15 +49,75 @@ export class ProviderDiscoveryService {
                 timeoutMs: 5_000
             });
             const version = spec.versionExtract?.(result.stdout) ?? result.stdout.trim();
+            const models = await this.discoverModels(spec);
             return {
                 name: spec.name,
                 command: spec.command,
                 available: true,
-                ...(version.length > 0 ? { version } : {})
+                ...(version.length > 0 ? { version } : {}),
+                ...(models.length > 0 ? { models } : {})
             };
         }
         catch {
             return { name: spec.name, command: spec.command, available: false };
         }
     }
+    async discoverModels(spec) {
+        for (const args of spec.modelListCommands ?? []) {
+            try {
+                const result = await this.commandRunner.run(spec.command, args, {
+                    timeoutMs: 5_000
+                });
+                const models = parseModelListOutput(result.stdout);
+                if (models.length > 0) {
+                    return models;
+                }
+            }
+            catch {
+                // Model listing is optional. Keep provider discovery available and fall back to defaults.
+            }
+        }
+        return [];
+    }
+}
+function parseModelListOutput(stdout) {
+    const models = [];
+    const seen = new Set();
+    for (const rawLine of stdout.split(/\r?\n/)) {
+        const model = normalizeModelListLine(rawLine);
+        if (model.length === 0 || seen.has(model)) {
+            continue;
+        }
+        models.push(model);
+        seen.add(model);
+    }
+    return models;
+}
+function normalizeModelListLine(line) {
+    const withoutBullet = line
+        .trim()
+        .replace(/^[*\-]\s*/, "")
+        .replace(/^\[[ xX]\]\s*/, "")
+        .replace(/^\d+[.)]\s*/, "")
+        .trim();
+    if (withoutBullet.length === 0 || withoutBullet.startsWith("#")) {
+        return "";
+    }
+    const jsonName = /"(?<key>id|name|model)"\s*:\s*"(?<value>[^"]+)"/.exec(withoutBullet);
+    if (jsonName?.groups?.value !== undefined) {
+        return jsonName.groups.value.trim();
+    }
+    const tableCells = withoutBullet.split("|").map((cell) => cell.trim()).filter(Boolean);
+    if (tableCells.length > 0 && tableCells.every((cell) => /^-+$/.test(cell))) {
+        return "";
+    }
+    if (tableCells.length > 1) {
+        return stripAnnotation(tableCells[0] ?? "");
+    }
+    return stripAnnotation(withoutBullet);
+}
+function stripAnnotation(value) {
+    return value
+        .replace(/\s+\((default|recommended|latest|beta|preview)\)$/i, "")
+        .trim();
 }

package/dist/src/onboarding/steps/configure-models.js

@@ -7,17 +7,19 @@ const STRONG_ROLES = [
     "retrospective"
 ];
 const CHEAP_ROLES = ["implementation", "discussion"];
-/** Suggested default model names per provider. */
+/** Provider-specific fallbacks used when the CLI cannot list Backburner model names. */
 const DEFAULT_MODELS = {
     claude: { strong: "claude-sonnet-4-6" },
-    codex: { strong: "o3" },
+    codex: { strong: "sol", cheap: "luna" },
     gemini: { strong: "gemini-3.1-pro-preview", cheap: "gemini-3-flash-preview" },
     opencode: { strong: "anthropic/claude-sonnet-4-6", cheap: "google/gemini-2.0-flash" },
     antigravity: { strong: "Gemini 3.1 Pro (High)", cheap: "Gemini 3.5 Flash (Low)" }
 };
-/** Preference order when choosing defaults for the user. */
-const STRONG_PREFERENCE = ["antigravity", "gemini", "claude", "codex", "opencode"];
-const CHEAP_PREFERENCE = ["antigravity", "gemini", "claude", "codex", "opencode"];
+const BACKBURNER_MODEL_DEFAULTS = {
+    strong: "sol",
+    balanced: "terra",
+    cheap: "luna"
+};
 export class ConfigureModelsStep {
     name = "configure-models";
     description = "Configure model assignments";
@@ -29,35 +31,31 @@ export class ConfigureModelsStep {
                 message: "Skipped: no providers available to configure"
             };
         }
-        const providerOptions = available.map((p) => `${p.name}${p.version !== undefined ? ` (${p.version})` : ""}`);
-        const providerNames = available.map((p) => p.name);
-        const defaultStrongIdx = indexOfFirstMatch(providerNames, STRONG_PREFERENCE);
-        const defaultCheapIdx = indexOfFirstMatch(providerNames, CHEAP_PREFERENCE);
-        let strongIdx;
-        let cheapIdx;
-        if (available.length === 1) {
-            strongIdx = 0;
-            cheapIdx = 0;
-        }
-        else {
-            process.stdout.write("\nStrong role tasks: product, planning, review, discussion, implementation_manager, retrospective\n");
-            strongIdx = await prompter.choose("Provider for strong tasks:", providerOptions, defaultStrongIdx);
-            process.stdout.write("\nCheap role tasks: implementation, discussion\n");
-            cheapIdx = await prompter.choose("Provider for cheap tasks:", providerOptions, defaultCheapIdx);
+        const providerOptions = available.map((p) => {
+            const modelNote = p.models !== undefined && p.models.length > 0
+                ? `, ${p.models.length} model${p.models.length === 1 ? "" : "s"}`
+                : "";
+            return `${p.name}${p.version !== undefined ? ` (${p.version}${modelNote})` : modelNote}`;
+        });
+        process.stdout.write("\nSelect providers to enable. Backburner will configure strong and cheap agents for each selected provider.\n");
+        process.stdout.write("Strong role tasks: product, planning, review, discussion, implementation_manager, retrospective\n");
+        process.stdout.write("Cheap role tasks: implementation, discussion\n");
+        const selectedProviderIndices = await prompter.multiSelect("Providers to enable:", providerOptions, available.map((_, index) => index));
+        const selectedProviders = selectedProviderIndices
+            .map((index) => available[index])
+            .filter((provider) => provider !== undefined);
+        if (selectedProviders.length === 0) {
+            return { status: "failed", message: "No providers selected for agent configuration" };
         }
-        const strongProvider = available[strongIdx];
-        const cheapProvider = available[cheapIdx];
-        if (strongProvider === undefined || cheapProvider === undefined) {
-            return { status: "failed", message: "Provider selection out of range" };
+        const agents = [];
+        for (const provider of selectedProviders) {
+            const strongDefault = selectDefaultModel(provider, "strong");
+            const cheapDefault = selectDefaultModel(provider, "cheap");
+            showAvailableModels(provider, strongDefault, cheapDefault);
+            const strongModel = await prompter.ask(`Model for ${provider.name} (strong):`, strongDefault);
+            const cheapModel = await prompter.ask(`Model for ${provider.name} (cheap):`, cheapDefault);
+            agents.push(buildAgent(`${provider.name}-strong`, provider.name, provider.command, "strong", STRONG_ROLES, strongModel || strongDefault), buildAgent(`${provider.name}-cheap`, provider.name, provider.command, "cheap", CHEAP_ROLES, cheapModel || cheapDefault));
         }
-        const strongDefaults = DEFAULT_MODELS[strongProvider.name];
-        const cheapDefaults = DEFAULT_MODELS[cheapProvider.name];
-        const strongModel = await prompter.ask(`Model for ${strongProvider.name} (strong):`, strongDefaults.strong);
-        const cheapModel = await prompter.ask(`Model for ${cheapProvider.name} (cheap):`, cheapDefaults.cheap ?? cheapDefaults.strong);
-        const agents = [
-            buildAgent(`${strongProvider.name}-strong`, strongProvider.name, strongProvider.command, "strong", STRONG_ROLES, strongModel || strongDefaults.strong),
-            buildAgent(`${cheapProvider.name}-cheap`, cheapProvider.name, cheapProvider.command, "cheap", CHEAP_ROLES, cheapModel || (cheapDefaults.cheap ?? cheapDefaults.strong))
-        ];
         if (ctx.configDraft === undefined) {
             ctx.configDraft = buildEmptyDraft(ctx);
         }
@@ -67,18 +65,81 @@ export class ConfigureModelsStep {
             message: `Configured ${agents.length} agents`,
             details: agents.map((a) => {
                 const modelNote = a.model !== undefined ? ` (${a.model})` : "";
-                return `${a.id}: ${a.provider}${modelNote} [${a.modelClass}] → ${a.roles.join(", ")}`;
+                return `${a.id}: ${a.provider}${modelNote} [${a.modelClass}] -> ${a.roles.join(", ")}`;
             })
         };
     }
 }
-function indexOfFirstMatch(names, preference) {
-    for (const pref of preference) {
-        const idx = names.indexOf(pref);
-        if (idx >= 0)
-            return idx;
+function showAvailableModels(provider, strongDefault, cheapDefault) {
+    const models = provider.models ?? [];
+    if (models.length === 0) {
+        process.stdout.write(`\n${provider.name} did not expose a model list. Press enter to use the defaults.\n`);
+        return;
+    }
+    const shownModels = rankModelOptions(models, [strongDefault, cheapDefault]);
+    process.stdout.write(`\nAvailable ${provider.name} models`);
+    if (shownModels.length < models.length) {
+        process.stdout.write(` (showing ${shownModels.length} of ${models.length})`);
+    }
+    process.stdout.write(":\n");
+    for (const model of shownModels) {
+        const labels = [
+            model === strongDefault ? "strong default" : undefined,
+            model === cheapDefault ? "cheap default" : undefined
+        ].filter((label) => label !== undefined);
+        const suffix = labels.length > 0 ? ` (${labels.join(", ")})` : "";
+        process.stdout.write(`  - ${model}${suffix}\n`);
+    }
+    process.stdout.write("Press enter at each prompt to accept the default, or type any model name.\n");
+}
+function rankModelOptions(models, defaults) {
+    const ranked = [];
+    const add = (model) => {
+        if (model !== undefined && model.length > 0 && !ranked.includes(model)) {
+            ranked.push(model);
+        }
+    };
+    for (const defaultModel of defaults) {
+        add(defaultModel);
+    }
+    for (const target of ["sol", "terra", "luna"]) {
+        add(findDiscoveredModel(models, [target]));
+    }
+    for (const model of models) {
+        add(model);
+        if (ranked.length >= 12) {
+            break;
+        }
+    }
+    return ranked;
+}
+function selectDefaultModel(provider, modelClass) {
+    const configuredDefaults = DEFAULT_MODELS[provider.name];
+    const backburnerDefault = BACKBURNER_MODEL_DEFAULTS[modelClass];
+    const providerDefault = configuredDefaults[modelClass] ?? configuredDefaults.strong;
+    const discoveredBackburnerDefault = findDiscoveredModel(provider.models ?? [], [
+        backburnerDefault
+    ]);
+    const discoveredProviderDefault = providerDefault !== undefined
+        ? findDiscoveredModel(provider.models ?? [], [providerDefault])
+        : undefined;
+    return discoveredBackburnerDefault ?? discoveredProviderDefault ?? providerDefault ?? backburnerDefault;
+}
+function findDiscoveredModel(models, candidates) {
+    for (const candidate of candidates) {
+        const match = models.find((model) => model.toLowerCase() === candidate.toLowerCase());
+        if (match !== undefined) {
+            return match;
+        }
+    }
+    for (const candidate of candidates) {
+        const normalizedCandidate = candidate.toLowerCase();
+        const match = models.find((model) => model.toLowerCase().includes(normalizedCandidate));
+        if (match !== undefined) {
+            return match;
+        }
     }
-    return 0;
+    return undefined;
 }
 function buildAgent(id, provider, command, modelClass, roles, model) {
     return {

package/dist/src/onboarding/steps/discover-providers.js

@@ -11,9 +11,15 @@ export class DiscoverProvidersStep {
         ctx.discoveredProviders = await service.discoverAll();
         const available = ctx.discoveredProviders.filter((p) => p.available);
         const unavailable = ctx.discoveredProviders.filter((p) => !p.available);
-        const details = ctx.discoveredProviders.map((p) => p.available
-            ? `✓ ${p.name} (${p.command}): ${p.version ?? "found"}`
-            : `✗ ${p.name} (${p.command}): not found`);
+        const details = ctx.discoveredProviders.map((p) => {
+            if (!p.available) {
+                return `x ${p.name} (${p.command}): not found`;
+            }
+            const modelNote = p.models !== undefined && p.models.length > 0
+                ? `, ${p.models.length} model${p.models.length === 1 ? "" : "s"} discovered`
+                : ", model list unavailable";
+            return `ok ${p.name} (${p.command}): ${p.version ?? "found"}${modelNote}`;
+        });
         if (available.length === 0) {
             ctx.warnings.push("No AI providers found. Install at least one of: antigravity, gemini, claude, codex, opencode");
             return {

package/dist/src/onboarding/steps/select-repos.js

@@ -1,8 +1,20 @@
+import { defaultDemoRepoName } from "../services/demo-repo.js";
 export class SelectReposStep {
+    demoRepoCreator;
     name = "select-repos";
     description = "Select repositories to manage";
+    constructor(demoRepoCreator) {
+        this.demoRepoCreator = demoRepoCreator;
+    }
     async run(ctx, prompter) {
         const { discoveredRepos } = ctx;
+        const setupChoice = await this.promptSetupChoice(ctx, prompter);
+        if (setupChoice === "demo") {
+            return await this.promptCreateDemoRepo(ctx, prompter);
+        }
+        if (setupChoice === "skip") {
+            return this.noRepositoryWarning();
+        }
         if (discoveredRepos.length === 0) {
             return await this.promptManualEntry(ctx, prompter);
         }
@@ -29,15 +41,7 @@ export class SelectReposStep {
             }
         }
         if (selected.length === 0) {
-            const fallback = await prompter.confirm("No repositories selected. Add one manually?", true);
-            if (fallback) {
-                return await this.promptManualEntry(ctx, prompter);
-            }
-            return {
-                status: "warning",
-                message: "No repositories selected",
-                details: ["You can add repositories by editing repos.json later."]
-            };
+            return await this.promptNoSelection(ctx, prompter);
         }
         ctx.selectedRepos = selected;
         return {
@@ -49,6 +53,95 @@ export class SelectReposStep {
             })
         };
     }
+    async promptSetupChoice(ctx, prompter) {
+        const hasDiscoveredRepos = ctx.discoveredRepos.length > 0;
+        const options = [
+            hasDiscoveredRepos
+                ? "Select existing repositories"
+                : "Enter an existing repository manually",
+            ...(ctx.githubUser !== undefined ? ["Create a private Backburner demo repo"] : []),
+            "Skip repository setup for now"
+        ];
+        const choice = await prompter.choose("How do you want to set up repositories?", options, 0);
+        if (choice === 0) {
+            return "existing";
+        }
+        if (ctx.githubUser !== undefined && choice === 1) {
+            return "demo";
+        }
+        return "skip";
+    }
+    async promptNoSelection(ctx, prompter) {
+        const options = [
+            "Add an existing repository manually",
+            ...(ctx.githubUser !== undefined ? ["Create a private Backburner demo repo"] : []),
+            "Skip repository setup for now"
+        ];
+        const defaultIndex = 0;
+        const choice = await prompter.choose("No repositories selected. How do you want to continue?", options, defaultIndex);
+        if (choice === 0) {
+            return await this.promptManualEntry(ctx, prompter);
+        }
+        if (ctx.githubUser !== undefined && choice === 1) {
+            return await this.promptCreateDemoRepo(ctx, prompter);
+        }
+        return this.noRepositoryWarning();
+    }
+    async promptCreateDemoRepo(ctx, prompter) {
+        if (ctx.githubUser === undefined) {
+            return this.noRepositoryWarning();
+        }
+        if (this.demoRepoCreator === undefined) {
+            return {
+                status: "warning",
+                message: "Private demo repo creation is unavailable",
+                details: ["You can create a private repository manually and re-run onboarding."]
+            };
+        }
+        const repoName = (await prompter.ask("Private demo repository name:", defaultDemoRepoName())).trim();
+        if (!isValidRepoName(repoName)) {
+            return {
+                status: "warning",
+                message: "Private demo repo was not created",
+                details: ["Repository names can contain letters, numbers, dots, underscores, and hyphens."]
+            };
+        }
+        const confirmed = await prompter.confirm(`Create private GitHub repository ${ctx.githubUser}/${repoName} and clone it under ${ctx.codeRoot}?`, false);
+        if (!confirmed) {
+            return this.noRepositoryWarning();
+        }
+        try {
+            const repo = await this.demoRepoCreator.createPrivateDemoRepo({
+                owner: ctx.githubUser,
+                name: repoName,
+                codeRoot: ctx.codeRoot
+            });
+            ctx.discoveredRepos = [repo, ...ctx.discoveredRepos];
+            ctx.selectedRepos = [repo];
+            return {
+                status: "passed",
+                message: `Private demo repository selected: ${repo.owner}/${repo.name}`,
+                details: [
+                    "Visibility: private",
+                    `Local clone: ${repo.localPath ?? `${repo.owner}/${repo.name}`}`
+                ]
+            };
+        }
+        catch (err) {
+            return {
+                status: "failed",
+                message: `Failed to create private demo repo: ${err instanceof Error ? err.message : String(err)}`,
+                issues: [
+                    {
+                        title: "Private demo repo creation failed",
+                        cause: err instanceof Error ? err.message : String(err),
+                        suggestedFix: "Create a private GitHub repository manually, clone it locally, then re-run onboarding.",
+                        canAutoRemediate: false
+                    }
+                ]
+            };
+        }
+    }
     async promptManualEntry(ctx, prompter) {
         const owner = (await prompter.ask("Repository owner (e.g. myorg):")).trim();
         const name = (await prompter.ask("Repository name (e.g. my-repo):")).trim();
@@ -73,4 +166,14 @@ export class SelectReposStep {
             message: `1 repository selected: ${owner}/${name}`
         };
     }
+    noRepositoryWarning() {
+        return {
+            status: "warning",
+            message: "No repositories selected",
+            details: ["You can add repositories by editing repos.json later."]
+        };
+    }
+}
+function isValidRepoName(name) {
+    return /^[A-Za-z0-9._-]+$/.test(name);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@backburner/cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "description": "Local GitHub-based agent orchestration CLI",
   "license": "MIT",