@backburner/cli 0.1.0 → 0.1.2

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/configure-paths.js

@@ -1,5 +1,5 @@
 import * as path from "node:path";
-import { defaultBackburnerManagementRoot, defaultBackburnerOutputsRoot, defaultWorkspacesRootForCodeRoot } from "../../utils/paths.js";
+import { defaultBackburnerManagementRoot, defaultBackburnerOutputsRoot, defaultWorkspacesRootForCodeRoot, resolveUserPath } from "../../utils/paths.js";
 export class ConfigurePathsStep {
     name = "configure-paths";
     description = "Configure directories";
@@ -15,10 +15,10 @@ export class ConfigurePathsStep {
         const outputsDir = await prompter.ask("Outputs directory (state, logs):", defaultOutputs);
         const logDir = await prompter.ask("Log directory:", ctx.logDir || path.join(outputsDir || defaultOutputs, "logs"));
         const workspacesDir = await prompter.ask("Local workspaces directory (where Backburner creates git worktrees):", defaultWorkspaces);
-        ctx.managementDir = managementDir || defaultManagement;
-        ctx.outputsDir = outputsDir || defaultOutputs;
-        ctx.logDir = logDir || path.join(ctx.outputsDir, "logs");
-        ctx.workspacesDir = workspacesDir || defaultWorkspaces;
+        ctx.managementDir = resolveUserPath(managementDir || defaultManagement);
+        ctx.outputsDir = resolveUserPath(outputsDir || defaultOutputs);
+        ctx.logDir = resolveUserPath(logDir || path.join(ctx.outputsDir, "logs"));
+        ctx.workspacesDir = resolveUserPath(workspacesDir || defaultWorkspaces);
         return {
             status: "passed",
             message: "Directories configured",

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/generate-config.js

@@ -1,5 +1,6 @@
 import * as path from "node:path";
 import { ConfigWriter } from "../config-writer.js";
+import { DEFAULT_BACKBURNER_LABELS } from "../config-writer.js";
 export class GenerateConfigStep {
     name = "generate-config";
     description = "Generating configuration";
@@ -101,6 +102,7 @@ function buildRepoDraft(repo, codeRoot) {
         name: repo.name,
         localPath,
         defaultBranch: repo.defaultBranch || "main",
-        enabled: true
+        enabled: true,
+        labels: { ...DEFAULT_BACKBURNER_LABELS }
     };
 }

package/dist/src/onboarding/steps/provision-labels.js

@@ -0,0 +1,104 @@
+import { GitHubLabelProvisioner } from "../services/label-provisioner.js";
+const LABEL_DEFINITIONS = {
+    agentInProgress: {
+        description: "Backburner is actively working on this item.",
+        color: "6F42C1"
+    },
+    agentProductApproved: {
+        description: "Approve Backburner to start product discovery from this issue.",
+        color: "2DA44E"
+    },
+    agentPlanApproved: {
+        description: "Approve Backburner to implement an accepted plan.",
+        color: "0969DA"
+    },
+    agentReview: {
+        description: "Ask Backburner to review this pull request.",
+        color: "BF8700"
+    },
+    planBreakdownNeeded: {
+        description: "Ask Backburner to break a plan into implementation packets.",
+        color: "8250DF"
+    },
+    agentSyncParentBranch: {
+        description: "Allow Backburner to sync the parent branch from the default branch.",
+        color: "1F883D"
+    },
+    prepareForMerge: {
+        description: "Ask Backburner to prepare this pull request for merge.",
+        color: "CF222E"
+    }
+};
+export class ProvisionLabelsStep {
+    commandRunner;
+    name = "provision-labels";
+    description = "Creating GitHub labels";
+    constructor(commandRunner) {
+        this.commandRunner = commandRunner;
+    }
+    async run(ctx, _prompter) {
+        const draft = ctx.configDraft;
+        if (draft === undefined || draft.repos.length === 0) {
+            return {
+                status: "skipped",
+                message: "Skipped: no repositories selected for label creation"
+            };
+        }
+        const targets = buildLabelTargets(draft);
+        const provisioner = new GitHubLabelProvisioner(this.commandRunner);
+        const results = await provisioner.provisionLabels(targets);
+        const failures = results.filter((result) => result.status === "failed");
+        if (failures.length > 0) {
+            ctx.warnings.push("Some GitHub labels could not be created. You can retry onboarding or create them manually from repos.json.");
+            return {
+                status: "warning",
+                message: `Created labels with ${failures.length} failure${failures.length === 1 ? "" : "s"}`,
+                details: [
+                    ...failures.map((failure) => {
+                        const suffix = failure.message !== undefined ? `: ${failure.message}` : "";
+                        return `${failure.repoSlug}: ${failure.labelName}${suffix}`;
+                    }),
+                    ...buildManualLabelDetails(targets)
+                ]
+            };
+        }
+        return {
+            status: "passed",
+            message: `Created or updated ${results.length} GitHub label${results.length === 1 ? "" : "s"}`,
+            details: targets.map((target) => `${target.owner}/${target.name}: ${target.labels.length} labels`)
+        };
+    }
+}
+function buildManualLabelDetails(targets) {
+    return targets.flatMap((target) => {
+        const repoSlug = `${target.owner}/${target.name}`;
+        return [
+            `Manual labels page for ${repoSlug}: https://github.com/${repoSlug}/labels`,
+            `Required labels: ${target.labels.map((label) => label.name).join(", ")}`
+        ];
+    });
+}
+function buildLabelTargets(draft) {
+    return draft.repos.map((repo) => ({
+        owner: repo.owner,
+        name: repo.name,
+        labels: buildRepoLabels(repo)
+    }));
+}
+function buildRepoLabels(repo) {
+    return [
+        buildLabel("agentInProgress", repo.labels.agentInProgress),
+        buildLabel("agentProductApproved", repo.labels.agentProductApproved),
+        buildLabel("agentPlanApproved", repo.labels.agentPlanApproved),
+        buildLabel("agentReview", repo.labels.agentReview),
+        buildLabel("planBreakdownNeeded", repo.labels.planBreakdownNeeded),
+        buildLabel("agentSyncParentBranch", repo.labels.agentSyncParentBranch),
+        buildLabel("prepareForMerge", repo.labels.prepareForMerge)
+    ];
+}
+function buildLabel(key, name) {
+    return {
+        name,
+        ...LABEL_DEFINITIONS[key]
+    };
+}

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 (Backburner will create/update its labels on them)"
+                : "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);
 }