@backburner/cli 0.1.0

package/dist/src/onboarding/prompt.js

@@ -0,0 +1,102 @@
+import * as readline from "node:readline/promises";
+/**
+ * Interactive prompter backed by Node.js readline/promises.
+ * Writes prompts to stdout; reads from stdin.
+ */
+export class NodeReadlinePrompter {
+    rl;
+    constructor() {
+        this.rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+    }
+    close() {
+        this.rl.close();
+    }
+    async ask(question, defaultValue) {
+        const hint = defaultValue !== undefined ? ` [${defaultValue}]` : "";
+        const answer = (await this.rl.question(`${question}${hint} `)).trim();
+        return answer.length > 0 ? answer : (defaultValue ?? "");
+    }
+    async confirm(question, defaultValue) {
+        const hint = defaultValue === true ? "[Y/n]" : defaultValue === false ? "[y/N]" : "[y/n]";
+        const answer = (await this.rl.question(`${question} ${hint} `)).trim().toLowerCase();
+        if (answer.length === 0)
+            return defaultValue ?? false;
+        return answer === "y" || answer === "yes";
+    }
+    async choose(question, options, defaultIndex) {
+        const lines = [question];
+        for (let i = 0; i < options.length; i++) {
+            const marker = i === defaultIndex ? "*" : " ";
+            lines.push(`  ${marker} ${i + 1}. ${options[i] ?? ""}`);
+        }
+        process.stdout.write(`${lines.join("\n")}\n`);
+        const defaultHint = defaultIndex !== undefined ? ` [${defaultIndex + 1}]` : "";
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const answer = (await this.rl.question(`Enter number${defaultHint}: `)).trim();
+            if (answer.length === 0 && defaultIndex !== undefined) {
+                return defaultIndex;
+            }
+            const n = Number(answer);
+            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`);
+        }
+    }
+    async multiSelect(question, options, preSelected) {
+        const preSet = new Set(preSelected ?? []);
+        const lines = [
+            question,
+            "(Enter comma-separated numbers, 'all' to select all, or leave empty for none)"
+        ];
+        for (let i = 0; i < options.length; i++) {
+            const marker = preSet.has(i) ? "[x]" : "[ ]";
+            lines.push(`  ${marker} ${i + 1}. ${options[i] ?? ""}`);
+        }
+        process.stdout.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);
+            }
+            if (valid)
+                return [...new Set(indices)];
+        }
+    }
+}
+/**
+ * Non-interactive prompter that accepts all defaults.
+ * Used when --yes is passed or in tests.
+ */
+export class NonInteractivePrompter {
+    ask(_question, defaultValue) {
+        return Promise.resolve(defaultValue ?? "");
+    }
+    confirm(_question, defaultValue) {
+        return Promise.resolve(defaultValue ?? true);
+    }
+    choose(_question, _options, defaultIndex) {
+        return Promise.resolve(defaultIndex ?? 0);
+    }
+    multiSelect(_question, options, preSelected) {
+        return Promise.resolve(preSelected ?? options.map((_, i) => i));
+    }
+}

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

@@ -0,0 +1,58 @@
+const PROVIDER_SPECS = [
+    {
+        name: "claude",
+        command: "claude",
+        versionArgs: ["--version"],
+        versionExtract: (out) => out.trim().split("\n")[0] ?? out.trim()
+    },
+    {
+        name: "codex",
+        command: "codex",
+        versionArgs: ["--version"],
+        versionExtract: (out) => out.trim()
+    },
+    {
+        name: "gemini",
+        command: "gemini",
+        versionArgs: ["--version"],
+        versionExtract: (out) => out.trim()
+    },
+    {
+        name: "opencode",
+        command: "opencode",
+        versionArgs: ["--version"],
+        versionExtract: (out) => out.trim()
+    },
+    {
+        name: "antigravity",
+        command: "agy",
+        versionArgs: ["--version"],
+        versionExtract: (out) => out.trim()
+    }
+];
+export class ProviderDiscoveryService {
+    commandRunner;
+    constructor(commandRunner) {
+        this.commandRunner = commandRunner;
+    }
+    async discoverAll() {
+        return Promise.all(PROVIDER_SPECS.map((spec) => this.checkProvider(spec)));
+    }
+    async checkProvider(spec) {
+        try {
+            const result = await this.commandRunner.run(spec.command, spec.versionArgs, {
+                timeoutMs: 5_000
+            });
+            const version = spec.versionExtract?.(result.stdout) ?? result.stdout.trim();
+            return {
+                name: spec.name,
+                command: spec.command,
+                available: true,
+                ...(version.length > 0 ? { version } : {})
+            };
+        }
+        catch {
+            return { name: spec.name, command: spec.command, available: false };
+        }
+    }
+}

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

@@ -0,0 +1,246 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+/** Candidate directories to scan for local git repos. */
+const DEFAULT_LOCAL_SEARCH_DIRS = [
+    path.join(os.homedir(), "repos"),
+    path.join(os.homedir(), "code"),
+    path.join(os.homedir(), "projects"),
+    path.join(os.homedir(), "src"),
+    path.join(os.homedir(), "work")
+];
+/**
+ * Directory names to skip when scanning for repos. These directories are
+ * either too large to scan usefully or are not likely to contain repos.
+ */
+const SKIP_DIRS = new Set([
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    ".cache",
+    ".npm",
+    ".yarn",
+    "vendor",
+    "coverage"
+]);
+export class RepoDiscoveryService {
+    commandRunner;
+    constructor(commandRunner) {
+        this.commandRunner = commandRunner;
+    }
+    /**
+     * Fetch repos accessible via the authenticated GitHub CLI account.
+     *
+     * Discovers the user's personal login and all org memberships via the GitHub
+     * API, then queries `gh repo list <owner>` for each. Falls back to a plain
+     * `gh repo list` (personal repos only) when the API calls fail.
+     */
+    async discoverGitHubRepos(limit = 100) {
+        const owners = await this.resolveGitHubOwners();
+        if (owners.length === 0) {
+            return this.listGitHubRepos(undefined, limit);
+        }
+        const allRepos = [];
+        const seen = new Set();
+        for (const owner of owners) {
+            for (const repo of await this.listGitHubRepos(owner, limit)) {
+                const key = `${repo.owner}/${repo.name}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    allRepos.push(repo);
+                }
+            }
+        }
+        return allRepos;
+    }
+    /** Returns the personal login plus all org logins the user is a member of. */
+    async resolveGitHubOwners() {
+        const owners = [];
+        try {
+            const userResult = await this.commandRunner.run("gh", ["api", "user", "--jq", ".login"], { timeoutMs: 10_000 });
+            const login = userResult.stdout.trim();
+            if (login.length > 0)
+                owners.push(login);
+        }
+        catch {
+            // ignore — will fall back to unscoped gh repo list
+        }
+        try {
+            const orgsResult = await this.commandRunner.run("gh", ["api", "user/orgs", "--jq", ".[].login"], { timeoutMs: 10_000 });
+            const orgLogins = orgsResult.stdout
+                .trim()
+                .split(/\r?\n/)
+                .filter((s) => s.length > 0);
+            owners.push(...orgLogins);
+        }
+        catch {
+            // ignore — org repos will just be absent
+        }
+        return owners;
+    }
+    async listGitHubRepos(owner, limit) {
+        try {
+            const args = [
+                "repo",
+                "list",
+                ...(owner !== undefined ? [owner] : []),
+                "--json",
+                "name,owner,defaultBranchRef",
+                "--limit",
+                String(limit)
+            ];
+            const result = await this.commandRunner.run("gh", args, { timeoutMs: 30_000 });
+            const repos = JSON.parse(result.stdout);
+            return repos.map((repo) => {
+                const defaultBranch = repo.defaultBranchRef?.name;
+                return {
+                    owner: repo.owner.login,
+                    name: repo.name,
+                    isLocalClone: false,
+                    ...(defaultBranch !== undefined ? { defaultBranch } : {})
+                };
+            });
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Scan one or more directories for GitHub-hosted git repositories.
+     *
+     * Supports two layouts:
+     *  - flat:       `<dir>/<repo>/.git`       (e.g. ~/repos/my-repo)
+     *  - owner/name: `<dir>/<owner>/<repo>/.git` (e.g. ~/code/myorg/my-repo)
+     *
+     * Hidden directories and heavy directories (node_modules, dist, …) are
+     * skipped. Traversal is bounded to depth 2.
+     */
+    async discoverLocalRepos(searchDirs) {
+        const dirs = searchDirs ?? DEFAULT_LOCAL_SEARCH_DIRS;
+        const repos = [];
+        const seen = new Set();
+        for (const dir of dirs) {
+            await this.scanDir(dir, repos, seen);
+        }
+        return repos;
+    }
+    /** Merge GitHub repo list with local discoveries, adding localPath where found. */
+    mergeRepos(githubRepos, localRepos) {
+        const repoMap = new Map();
+        for (const repo of githubRepos) {
+            repoMap.set(`${repo.owner}/${repo.name}`, repo);
+        }
+        for (const local of localRepos) {
+            const key = `${local.owner}/${local.name}`;
+            const existing = repoMap.get(key);
+            if (existing) {
+                repoMap.set(key, {
+                    ...existing,
+                    isLocalClone: true,
+                    ...(local.localPath !== undefined ? { localPath: local.localPath } : {})
+                });
+            }
+            else {
+                repoMap.set(key, local);
+            }
+        }
+        return Array.from(repoMap.values());
+    }
+    /**
+     * Scan `dir` at up to depth 2.
+     *
+     * - Depth 1: `<dir>/<entry>` — try as a repo; if not, recurse into it as a
+     *   potential owner directory (to handle `<dir>/<owner>/<repo>`).
+     * - Depth 2: `<dir>/<owner>/<entry>` — try as a repo only (no further recursion).
+     */
+    async scanDir(dir, repos, seen) {
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (shouldSkip(entry.name))
+                continue;
+            const childPath = path.join(dir, entry.name);
+            // Try it as a direct repo first.
+            const repo = await this.tryReadGitRepo(childPath);
+            if (repo !== undefined) {
+                addUnique(repo, repos, seen);
+                continue;
+            }
+            // Not a repo — treat it as a potential owner directory and scan one level
+            // deeper (bounded; we do not recurse further from depth-2 entries).
+            let subEntries;
+            try {
+                subEntries = await fs.readdir(childPath, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const sub of subEntries) {
+                if (!sub.isDirectory())
+                    continue;
+                if (shouldSkip(sub.name))
+                    continue;
+                const subPath = path.join(childPath, sub.name);
+                const subRepo = await this.tryReadGitRepo(subPath);
+                if (subRepo !== undefined) {
+                    addUnique(subRepo, repos, seen);
+                }
+            }
+        }
+    }
+    async tryReadGitRepo(dirPath) {
+        try {
+            await fs.access(path.join(dirPath, ".git"));
+        }
+        catch {
+            return undefined;
+        }
+        try {
+            const result = await this.commandRunner.run("git", ["remote", "get-url", "origin"], { cwd: dirPath, timeoutMs: 5_000 });
+            const parsed = parseGitHubRemoteUrl(result.stdout.trim());
+            if (!parsed)
+                return undefined;
+            return {
+                owner: parsed.owner,
+                name: parsed.name,
+                localPath: dirPath,
+                isLocalClone: true
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+function shouldSkip(name) {
+    return name.startsWith(".") || SKIP_DIRS.has(name);
+}
+function addUnique(repo, repos, seen) {
+    const key = repo.localPath ?? `${repo.owner}/${repo.name}`;
+    if (!seen.has(key)) {
+        seen.add(key);
+        repos.push(repo);
+    }
+}
+function parseGitHubRemoteUrl(url) {
+    // SSH: git@github.com:owner/repo.git
+    const ssh = url.match(/git@github\.com[:/]([^/]+)\/([^/]+?)(?:\.git)?$/);
+    if (ssh?.[1] && ssh[2]) {
+        return { owner: ssh[1], name: ssh[2] };
+    }
+    // HTTPS: https://github.com/owner/repo or https://github.com/owner/repo.git
+    const https = url.match(/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?(?:\s|$)/);
+    if (https?.[1] && https[2]) {
+        return { owner: https[1], name: https[2] };
+    }
+    return undefined;
+}
+export { parseGitHubRemoteUrl };

package/dist/src/onboarding/steps/check-github-auth.js

@@ -0,0 +1,32 @@
+import { GitHubAuthChecker } from "../validators/github-auth.js";
+export class CheckGitHubAuthStep {
+    commandRunner;
+    name = "check-github-auth";
+    description = "Validating GitHub authentication";
+    constructor(commandRunner) {
+        this.commandRunner = commandRunner;
+    }
+    async run(ctx, _prompter) {
+        const checker = new GitHubAuthChecker(this.commandRunner);
+        const authResult = await checker.check();
+        if (!authResult.authenticated) {
+            return {
+                status: "requiresUserAction",
+                message: "Not authenticated with GitHub",
+                issues: authResult.issue !== undefined ? [authResult.issue] : []
+            };
+        }
+        let username = authResult.username;
+        if (username === undefined || username.length === 0) {
+            username = await checker.getAuthenticatedUser();
+        }
+        if (username !== undefined && username.length > 0) {
+            ctx.githubUser = username;
+        }
+        return {
+            status: "passed",
+            message: `Authenticated as ${username ?? "unknown"}`,
+            ...(username !== undefined ? { details: [`GitHub user: ${username}`] } : {})
+        };
+    }
+}

package/dist/src/onboarding/steps/check-requirements.js

@@ -0,0 +1,34 @@
+import { ToolChecker } from "../validators/tool-checker.js";
+export class CheckRequirementsStep {
+    commandRunner;
+    name = "check-requirements";
+    description = "Checking required tools";
+    constructor(commandRunner) {
+        this.commandRunner = commandRunner;
+    }
+    async run(ctx, _prompter) {
+        const checker = new ToolChecker(this.commandRunner);
+        const results = await checker.checkAll();
+        const missing = results.filter((r) => !r.available);
+        const details = results.map((r) => r.available ? `✓ ${r.name}: ${r.version ?? "found"}` : `✗ ${r.name}: not found`);
+        if (missing.length === 0) {
+            return {
+                status: "passed",
+                message: `All ${results.length} required tools found`,
+                details
+            };
+        }
+        for (const r of missing) {
+            ctx.warnings.push(`Required tool not found: ${r.name} (${r.command})`);
+        }
+        const issues = missing
+            .map((r) => r.issue)
+            .filter((issue) => issue !== undefined);
+        return {
+            status: "failed",
+            message: `${missing.length} required tool(s) missing: ${missing.map((r) => r.name).join(", ")}`,
+            details,
+            issues
+        };
+    }
+}

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

@@ -0,0 +1,105 @@
+const STRONG_ROLES = [
+    "product",
+    "planning",
+    "review",
+    "discussion",
+    "implementation_manager",
+    "retrospective"
+];
+const CHEAP_ROLES = ["implementation", "discussion"];
+/** Suggested default model names per provider. */
+const DEFAULT_MODELS = {
+    claude: { strong: "claude-sonnet-4-6" },
+    codex: { strong: "o3" },
+    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"];
+export class ConfigureModelsStep {
+    name = "configure-models";
+    description = "Configure model assignments";
+    async run(ctx, prompter) {
+        const available = ctx.discoveredProviders.filter((p) => p.available);
+        if (available.length === 0) {
+            return {
+                status: "skipped",
+                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 strongProvider = available[strongIdx];
+        const cheapProvider = available[cheapIdx];
+        if (strongProvider === undefined || cheapProvider === undefined) {
+            return { status: "failed", message: "Provider selection out of range" };
+        }
+        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);
+        }
+        ctx.configDraft.agents = agents;
+        return {
+            status: "passed",
+            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(", ")}`;
+            })
+        };
+    }
+}
+function indexOfFirstMatch(names, preference) {
+    for (const pref of preference) {
+        const idx = names.indexOf(pref);
+        if (idx >= 0)
+            return idx;
+    }
+    return 0;
+}
+function buildAgent(id, provider, command, modelClass, roles, model) {
+    return {
+        id,
+        provider,
+        command,
+        modelClass,
+        roles,
+        enabled: true,
+        ...(model !== undefined && model.length > 0 ? { model } : {})
+    };
+}
+function buildEmptyDraft(ctx) {
+    return {
+        codeRoot: ctx.codeRoot,
+        managementDir: ctx.managementDir,
+        outputsDir: ctx.outputsDir,
+        logDir: ctx.logDir,
+        workspacesDir: ctx.workspacesDir,
+        allowedUsers: ctx.githubUser !== undefined ? [ctx.githubUser] : [],
+        repos: [],
+        agents: []
+    };
+}

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

@@ -0,0 +1,33 @@
+import * as path from "node:path";
+import { defaultBackburnerManagementRoot, defaultBackburnerOutputsRoot, defaultWorkspacesRootForCodeRoot } from "../../utils/paths.js";
+export class ConfigurePathsStep {
+    name = "configure-paths";
+    description = "Configure directories";
+    async run(ctx, prompter) {
+        // Use current ctx values as defaults so that CLI-supplied flags are preserved.
+        // Only fall back to ~/.backburner/* when the context has no value (shouldn't happen
+        // if runInit initialised ctx properly, but is a safety net).
+        const defaultManagement = ctx.managementDir || defaultBackburnerManagementRoot();
+        const defaultOutputs = ctx.outputsDir || defaultBackburnerOutputsRoot();
+        const defaultLog = ctx.logDir || path.join(defaultOutputs, "logs");
+        const defaultWorkspaces = ctx.workspacesDir || defaultWorkspacesRootForCodeRoot(ctx.codeRoot);
+        const managementDir = await prompter.ask("Management directory (Backburner config and prompt files):", defaultManagement);
+        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;
+        return {
+            status: "passed",
+            message: "Directories configured",
+            details: [
+                `Management: ${ctx.managementDir}`,
+                `Outputs:    ${ctx.outputsDir}`,
+                `Logs:       ${ctx.logDir}`,
+                `Workspaces: ${ctx.workspacesDir}`
+            ]
+        };
+    }
+}

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

@@ -0,0 +1,38 @@
+import { ProviderDiscoveryService } from "../services/provider-discovery.js";
+export class DiscoverProvidersStep {
+    commandRunner;
+    name = "discover-providers";
+    description = "Detecting available AI providers";
+    constructor(commandRunner) {
+        this.commandRunner = commandRunner;
+    }
+    async run(ctx, _prompter) {
+        const service = new ProviderDiscoveryService(this.commandRunner);
+        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`);
+        if (available.length === 0) {
+            ctx.warnings.push("No AI providers found. Install at least one of: antigravity, gemini, claude, codex, opencode");
+            return {
+                status: "warning",
+                message: "No AI providers found",
+                details: [
+                    ...details,
+                    "",
+                    "Install at least one provider before running agents."
+                ]
+            };
+        }
+        const unavailableNote = unavailable.length > 0
+            ? ` (${unavailable.length} not found)`
+            : "";
+        return {
+            status: "passed",
+            message: `${available.length} provider${available.length === 1 ? "" : "s"} available: ${available.map((p) => p.name).join(", ")}${unavailableNote}`,
+            details
+        };
+    }
+}