@backburner/cli 0.1.0

package/dist/src/agents/lifecycle-feedback.js

@@ -0,0 +1,147 @@
+import { Task } from "../tasks/task.js";
+export class GitHubTaskLifecycleNotifier {
+    gitHubGateway;
+    logger;
+    reposById;
+    constructor(gitHubGateway, repos, logger) {
+        this.gitHubGateway = gitHubGateway;
+        this.logger = logger;
+        this.reposById = new Map(repos.map((repo) => [repo.id, repo]));
+    }
+    async notifyDispatch(taskRecord, { isRetry }) {
+        const task = Task.from(taskRecord);
+        const repo = this.reposById.get(taskRecord.repoId);
+        if (!repo) {
+            this.logger?.warn(`Could not resolve repo ${taskRecord.repoId} for task lifecycle feedback.`);
+            return;
+        }
+        // Best-effort reaction
+        try {
+            const eyesSourceNumber = task.getSourceEntityNumber();
+            const eyesCommentId = task.getSourceCommentId();
+            const eyesCommentKind = task.getSourceCommentKind();
+            await this.gitHubGateway.addReaction({
+                owner: repo.owner,
+                name: repo.name,
+                ...(eyesSourceNumber !== undefined ? { issueNumber: eyesSourceNumber } : {}),
+                ...(eyesCommentId !== undefined ? { commentId: eyesCommentId } : {}),
+                ...(eyesCommentKind !== undefined ? { commentKind: eyesCommentKind } : {}),
+                content: "eyes"
+            });
+        }
+        catch (error) {
+            this.logger?.warn(`Failed to add reaction for task ${taskRecord.id}: ${error}`);
+        }
+        // Best-effort comment
+        try {
+            const threadNumber = task.owningThreadNumber();
+            if (threadNumber !== undefined) {
+                const suffix = isRetry ? " (this is a re-run)" : "";
+                const body = `🤖 I noticed this task and I'm starting work on it: **${taskRecord.summary}**${suffix}`;
+                await this.gitHubGateway.postIssueComment({
+                    owner: repo.owner,
+                    name: repo.name,
+                    issueNumber: threadNumber,
+                    body
+                });
+            }
+        }
+        catch (error) {
+            this.logger?.warn(`Failed to post dispatch lifecycle feedback for task ${taskRecord.id}: ${error}`);
+        }
+    }
+    async notifyCompletionStatus(taskRecord, status) {
+        const task = Task.from(taskRecord);
+        const repo = this.reposById.get(taskRecord.repoId);
+        if (!repo)
+            return;
+        try {
+            const sourceNumber = task.getSourceEntityNumber();
+            const commentId = task.getSourceCommentId();
+            const commentKind = task.getSourceCommentKind();
+            await this.gitHubGateway.addReaction({
+                owner: repo.owner,
+                name: repo.name,
+                ...(sourceNumber !== undefined ? { issueNumber: sourceNumber } : {}),
+                ...(commentId !== undefined ? { commentId: commentId } : {}),
+                ...(commentKind !== undefined ? { commentKind } : {}),
+                content: status === "completed" ? "+1" : "-1"
+            });
+        }
+        catch (error) {
+            this.logger?.warn(`Failed to post completion reaction for task ${taskRecord.id}: ${error}`);
+        }
+    }
+    async notifyQueued(taskRecord, providers, resetTime) {
+        const task = Task.from(taskRecord);
+        const repo = this.reposById.get(taskRecord.repoId);
+        if (!repo) {
+            this.logger?.warn(`Could not resolve repo ${taskRecord.repoId} for task lifecycle feedback.`);
+            return;
+        }
+        const providerList = Array.isArray(providers) ? providers : [providers];
+        const providersStr = providerList.map(p => `\`${p}\``).join(", ");
+        try {
+            const threadNumber = task.owningThreadNumber();
+            if (threadNumber !== undefined) {
+                const resetMsg = resetTime ? ` until ${resetTime}` : "";
+                const providerText = providerList.length > 1 ? "providers" : "provider";
+                const body = `🤖 I've queued this task because the AI ${providerText} (${providersStr}) has hit its session/rate limit${resetMsg}. It will resume automatically once the limit resets.`;
+                await this.gitHubGateway.postIssueComment({
+                    owner: repo.owner,
+                    name: repo.name,
+                    issueNumber: threadNumber,
+                    body
+                });
+            }
+        }
+        catch (error) {
+            this.logger?.warn(`Failed to post queued lifecycle feedback for task ${taskRecord.id}: ${error}`);
+        }
+    }
+    async notifyResumed(taskRecord) {
+        const task = Task.from(taskRecord);
+        const repo = this.reposById.get(taskRecord.repoId);
+        if (!repo) {
+            this.logger?.warn(`Could not resolve repo ${taskRecord.repoId} for task lifecycle feedback.`);
+            return;
+        }
+        try {
+            const threadNumber = task.owningThreadNumber();
+            if (threadNumber !== undefined) {
+                const body = `🤖 Resuming task: **${taskRecord.summary}**`;
+                await this.gitHubGateway.postIssueComment({
+                    owner: repo.owner,
+                    name: repo.name,
+                    issueNumber: threadNumber,
+                    body
+                });
+            }
+        }
+        catch (error) {
+            this.logger?.warn(`Failed to post resumed lifecycle feedback for task ${taskRecord.id}: ${error}`);
+        }
+    }
+    async notifyCanceled(taskRecord) {
+        const task = Task.from(taskRecord);
+        const repo = this.reposById.get(taskRecord.repoId);
+        if (!repo) {
+            this.logger?.warn(`Could not resolve repo ${taskRecord.repoId} for task lifecycle feedback.`);
+            return;
+        }
+        try {
+            const threadNumber = task.owningThreadNumber();
+            if (threadNumber !== undefined) {
+                await this.gitHubGateway.postIssueComment({
+                    owner: repo.owner,
+                    name: repo.name,
+                    issueNumber: threadNumber,
+                    body: "🤖 Task was canceled or the PR/issue was closed while queued."
+                });
+            }
+        }
+        catch (error) {
+            this.logger?.warn(`Failed to post canceled lifecycle feedback for task ${taskRecord.id}: ${error}`);
+        }
+    }
+}

package/dist/src/agents/limit-detector.js

@@ -0,0 +1,83 @@
+export function detectProviderLimit(provider, exitCode, stdout, stderr) {
+    const combined = (stdout + "\n" + stderr).toLowerCase();
+    let isLimited = false;
+    let limitType = undefined;
+    if (exitCode === 429) {
+        isLimited = true;
+        limitType = "session";
+    }
+    if (provider === "claude") {
+        if (combined.includes("rate limit exceeded") || combined.includes("quota exceeded") || combined.includes("too many requests") || exitCode === 429) {
+            isLimited = true;
+        }
+        if (combined.includes("5-hour limit") || combined.includes("five-hour limit") || combined.includes("session limit")) {
+            isLimited = true;
+            limitType = "session";
+        }
+        if (combined.includes("weekly limit")) {
+            isLimited = true;
+            limitType = "weekly";
+        }
+    }
+    if (provider === "codex") {
+        if (/rate limit|quota exceeded|billing limit/i.test(combined) || combined.includes("budget exceeded") || combined.includes("thread rate limit") || combined.includes("too many requests") || exitCode === 429) {
+            isLimited = true;
+        }
+    }
+    if (provider === "gemini") {
+        if (combined.includes("quota_exhausted") ||
+            combined.includes("resource_exhausted") ||
+            combined.includes("model_capacity_exhausted") ||
+            combined.includes("quota exhausted") ||
+            combined.includes("rate limit") ||
+            combined.includes("limit exceeded") ||
+            combined.includes("too many requests") ||
+            exitCode === 429) {
+            isLimited = true;
+        }
+    }
+    if (provider === "opencode") {
+        if (/rate limit|exhausted|quota/i.test(combined) || combined.includes("limit exceeded") || combined.includes("too many requests") || exitCode === 429) {
+            isLimited = true;
+        }
+    }
+    if (provider === "antigravity") {
+        if (/rate limit|usage cap|quota|session limit/i.test(combined) || combined.includes("limit exceeded") || combined.includes("too many requests") || exitCode === 429) {
+            isLimited = true;
+        }
+    }
+    if (isLimited) {
+        const now = new Date();
+        let resetTime;
+        if (limitType === "weekly") {
+            resetTime = new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000);
+        }
+        else if (limitType === "session" || combined.includes("5-hour limit")) {
+            limitType = "session";
+            resetTime = new Date(now.getTime() + 5 * 60 * 60 * 1000);
+        }
+        else {
+            resetTime = new Date(now.getTime() + 1 * 60 * 60 * 1000);
+        }
+        return {
+            provider,
+            isLimited: true,
+            limitType,
+            rawError: stderr.trim() || stdout.trim() || `Exit code ${exitCode}`,
+            detectedAt: now.toISOString(),
+            resetTime: resetTime.toISOString()
+        };
+    }
+    return undefined;
+}
+export function mapSignalToRecord(signal, nowIso) {
+    return {
+        provider: signal.provider,
+        status: signal.isLimited ? "limited" : "available",
+        limitType: signal.limitType,
+        rawError: signal.rawError,
+        detectedAt: signal.detectedAt,
+        resetTime: signal.resetTime,
+        updatedAt: nowIso
+    };
+}

package/dist/src/agents/opencode-launch.js

@@ -0,0 +1,138 @@
+import { writeJsonFileAtomic } from "../utils/json.js";
+/**
+ * Builds OpenCode CLI arguments.
+ * Prompt is passed as the last positional argument.
+ */
+export function buildOpenCodeCliArgs(options) {
+    return [
+        "run",
+        "--model",
+        options.model,
+        "--format",
+        "json",
+        "--dir",
+        options.repoPath,
+        options.promptText
+    ];
+}
+/**
+ * Writes the per-run OpenCode config JSON that wires the broker MCP server.
+ */
+export async function writeOpenCodeConfig(configPath, options) {
+    const config = options.mcp ? buildMcpConfig(options.mcp) : {};
+    await writeJsonFileAtomic(configPath, config);
+}
+/**
+ * Normalizes an MCP tool name for OpenCode.
+ * OpenCode replaces characters outside [a-zA-Z0-9_-] with _.
+ */
+export function normalizeOpenCodeMcpToolName(serverName, toolName) {
+    const sanitizedTool = toolName.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return `${serverName}_${sanitizedTool}`;
+}
+/**
+ * Builds the MCP configuration block.
+ */
+function buildMcpConfig(mcp) {
+    const tools = {
+        [`${mcp.serverName}_*`]: false
+    };
+    for (const tool of mcp.toolAllowList) {
+        tools[normalizeOpenCodeMcpToolName(mcp.serverName, tool)] = true;
+    }
+    return {
+        mcp: {
+            [mcp.serverName]: {
+                type: "remote",
+                url: mcp.serverUrl
+            }
+        },
+        tools
+    };
+}
+/**
+ * Returns the env var that points OpenCode at the generated config.
+ */
+export function getOpenCodeEnvOverrides(configPath) {
+    return { OPENCODE_CONFIG: configPath };
+}
+/**
+ * Normalizes OpenCode --format json output into assistant text.
+ * Skips non-JSON lines and accumulates content from text/message events.
+ */
+export function extractOpenCodeAssistantText(streamText) {
+    if (!streamText.trim()) {
+        return undefined;
+    }
+    let assistantText = "";
+    let sawAssistantMessage = false;
+    let fallbackResult;
+    for (const line of streamText.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        let event;
+        try {
+            event = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if (!event || typeof event !== "object") {
+            continue;
+        }
+        // Primary: type "text" with part.text (observed in implementation)
+        if (event.type === "text" && event.part && typeof event.part.text === "string") {
+            assistantText += event.part.text;
+            sawAssistantMessage = true;
+            continue;
+        }
+        // Secondary: type "message" with content (standard provider event)
+        if (event.type === "message" && event.role === "assistant" && typeof event.content === "string") {
+            assistantText += event.content;
+            sawAssistantMessage = true;
+            continue;
+        }
+        // Fallback: type "result" or "output"
+        if (!sawAssistantMessage && !fallbackResult) {
+            if (event.type === "result" || event.type === "output") {
+                if (typeof event.text === "string") {
+                    fallbackResult = event.text;
+                }
+                else if (event.part && typeof event.part.text === "string") {
+                    fallbackResult = event.part.text;
+                }
+                else if (typeof event.content === "string") {
+                    fallbackResult = event.content;
+                }
+            }
+        }
+    }
+    if (sawAssistantMessage && assistantText.trim()) {
+        return assistantText;
+    }
+    return fallbackResult;
+}
+export function buildGlobalOpenCodeLaunchInstructions(input) {
+    return [
+        "# Global OpenCode Instructions",
+        "",
+        "These instructions apply across repositories for this orchestrated run.",
+        "",
+        "## MCP Server",
+        `Use the local MCP server \`${input.mcp.serverName}\` for managed GitHub operations.`,
+        "- Invoke broker tools instead of using \`gh\` directly.",
+        "",
+        "Enabled broker tools for this run:",
+        ...input.mcp.toolAllowList.map((tool) => `- \`${normalizeOpenCodeMcpToolName(input.mcp.serverName, tool)}\``),
+        "",
+        "Any GitHub-authored message you post must begin with \`🤖\`."
+    ].join("\n");
+}
+export function prependGlobalOpenCodeLaunchInstructions(promptText, options) {
+    if (!options.mcp) {
+        return promptText;
+    }
+    return `${buildGlobalOpenCodeLaunchInstructions({ mcp: options.mcp })}\n\n${promptText}`;
+}

package/dist/src/agents/opencode.js

@@ -0,0 +1,156 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import * as path from "node:path";
+import { writeJsonFileAtomic } from "../utils/json.js";
+import { buildOpenCodeCliArgs, extractOpenCodeAssistantText, getOpenCodeEnvOverrides, prependGlobalOpenCodeLaunchInstructions, writeOpenCodeConfig } from "./opencode-launch.js";
+import { buildExecutionId, extractAndExportPlanBreakdownResult, extractAndExportWaveAssessmentResult, extractExitCode, extractReviewResult, extractStderr, extractStdout, extractTriageResult, detectProviderLimit } from "./extraction.js";
+import { buildPromptPacket, renderPrompt } from "./prompt.js";
+const DEFAULT_TIMEOUT_MS = 15 * 60 * 1000;
+export class OpenCodeCliAgent {
+    options;
+    now;
+    timeoutMs;
+    logger;
+    constructor(options) {
+        this.options = options;
+        this.now = options.now ?? (() => new Date().toISOString());
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.logger = options.logger;
+    }
+    async dispatch(task, context, agentConfig, _sessionDecision, promptContent) {
+        const promptPacket = buildPromptPacket(task, context);
+        const promptText = prependGlobalOpenCodeLaunchInstructions(renderPrompt(task, promptPacket, {
+            providerIdentity: "OpenCode CLI",
+            customConstraints: promptContent?.content
+        }), { ...(this.options.githubBroker ? { mcp: this.options.githubBroker } : {}) });
+        const startedAt = this.now();
+        const executionId = buildExecutionId(task.id, startedAt);
+        const artifactDir = path.join(this.options.logDir, "artifacts", executionId);
+        const promptPacketPath = path.join(artifactDir, "prompt-packet.json");
+        const promptArtifactPath = path.join(artifactDir, "prompt.md");
+        const stdoutArtifactPath = path.join(artifactDir, "stdout.txt");
+        const stderrArtifactPath = path.join(artifactDir, "stderr.txt");
+        const streamArtifactPath = path.join(artifactDir, "stdout-events.jsonl");
+        const settingsArtifactPath = path.join(artifactDir, "opencode-config.json");
+        await mkdir(artifactDir, { recursive: true });
+        await writeOpenCodeConfig(settingsArtifactPath, {
+            ...(this.options.githubBroker ? { mcp: this.options.githubBroker } : {})
+        });
+        await Promise.all([
+            writeJsonFileAtomic(promptPacketPath, promptPacket),
+            writeFile(promptArtifactPath, promptText, "utf8")
+        ]);
+        const envOverrides = getOpenCodeEnvOverrides(settingsArtifactPath);
+        const cwd = context.localRepoPath ?? process.cwd();
+        this.logger?.info(JSON.stringify({
+            component: "opencode-launch",
+            taskKind: task.kind,
+            targetRepoPath: cwd,
+            configPath: settingsArtifactPath,
+            mcpServerUrl: this.options.githubBroker?.serverUrl
+        }));
+        const args = buildOpenCodeCliArgs({
+            model: agentConfig.model, // Schema ensures model is present for opencode
+            repoPath: cwd,
+            promptText
+        });
+        let rawStdout = "";
+        let rawStderr = "";
+        let exitCode = 0;
+        try {
+            const result = await this.options.commandRunner.run(agentConfig.command, args, {
+                cwd,
+                env: { ...process.env, ...envOverrides },
+                timeoutMs: this.timeoutMs
+            });
+            rawStdout = result.stdout;
+            rawStderr = result.stderr;
+            exitCode = result.exitCode;
+        }
+        catch (error) {
+            exitCode = extractExitCode(error);
+            rawStdout = extractStdout(error);
+            rawStderr = extractStderr(error);
+        }
+        const normalizedStdout = extractOpenCodeAssistantText(rawStdout) ?? rawStdout;
+        const endedAt = this.now();
+        await Promise.all([
+            writeFile(streamArtifactPath, rawStdout, "utf8"),
+            writeFile(stdoutArtifactPath, normalizedStdout, "utf8"),
+            writeFile(stderrArtifactPath, rawStderr, "utf8")
+        ]);
+        const triageResult = extractTriageResult(task, normalizedStdout);
+        const reviewResult = extractReviewResult(task, normalizedStdout);
+        const planBreakdownExtraction = extractAndExportPlanBreakdownResult(task, normalizedStdout, this.options.planBreakdownSessionStore);
+        const waveAssessmentExtraction = extractAndExportWaveAssessmentResult(task, normalizedStdout, this.options.waveAssessmentSessionStore);
+        let taskStatus = exitCode === 0 ? "completed" : "failed";
+        let errorMessage = exitCode === 0 ? undefined : rawStderr.trim() || "OpenCode CLI exited with a non-zero status.";
+        if (task.kind === "review_pr" && exitCode === 0 && !reviewResult) {
+            taskStatus = "failed";
+            errorMessage = "Agent output did not contain a valid structured review result.";
+        }
+        if ((task.kind === "plan_breakdown" || task.kind === "wave_plan_replanning") && exitCode === 0) {
+            if (!planBreakdownExtraction.ok) {
+                taskStatus = "failed";
+                errorMessage = planBreakdownExtraction.message;
+            }
+        }
+        if (task.kind === "wave_plan_assessment" && exitCode === 0) {
+            if (!waveAssessmentExtraction.ok) {
+                taskStatus = "failed";
+                errorMessage = waveAssessmentExtraction.message;
+            }
+        }
+        const execution = {
+            id: executionId,
+            taskId: task.id,
+            taskKind: task.kind,
+            taskStatus,
+            repoId: task.repoId,
+            repoSlug: task.repoSlug,
+            agentId: agentConfig.id,
+            agentProvider: "opencode",
+            agentModel: agentConfig.model,
+            command: {
+                executable: agentConfig.command,
+                args,
+                cwd,
+                timeoutMs: this.timeoutMs
+            },
+            promptArtifactPath,
+            stdoutArtifactPath,
+            stderrArtifactPath,
+            streamArtifactPath,
+            promptPacketPath,
+            settingsArtifactPath,
+            startedAt,
+            endedAt,
+            exitCode,
+            ...(errorMessage ? { errorMessage } : {}),
+            ...(triageResult || reviewResult || planBreakdownExtraction.ok || waveAssessmentExtraction.ok
+                ? {
+                    result: {
+                        ...(triageResult ? { triage: triageResult } : {}),
+                        ...(reviewResult ? { review: reviewResult } : {}),
+                        ...(planBreakdownExtraction.ok
+                            ? {
+                                planBreakdown: planBreakdownExtraction.planBreakdown,
+                                planBreakdownSessionId: planBreakdownExtraction.sessionId
+                            }
+                            : {}),
+                        ...(waveAssessmentExtraction.ok
+                            ? {
+                                waveAssessment: waveAssessmentExtraction.waveAssessment
+                            }
+                            : {})
+                    }
+                }
+                : {})
+        };
+        const providerLimitSignal = detectProviderLimit("opencode", exitCode, rawStdout, rawStderr);
+        return {
+            taskStatus: execution.taskStatus,
+            execution,
+            ...(providerLimitSignal ? { providerLimitSignal } : {})
+        };
+    }
+}

package/dist/src/agents/plan-breakdown-feedback.js

@@ -0,0 +1,97 @@
+import { Task } from "../tasks/task.js";
+export class GitHubPlanBreakdownPublisher {
+    gitHubGateway;
+    logger;
+    reposById;
+    constructor(gitHubGateway, repos, logger) {
+        this.gitHubGateway = gitHubGateway;
+        this.logger = logger;
+        this.reposById = new Map(repos.map((repo) => [repo.id, repo]));
+    }
+    async publishBreakdown(task, execution) {
+        if (task.kind !== "plan_breakdown" || execution.taskStatus !== "completed") {
+            return;
+        }
+        const breakdown = execution.result?.planBreakdown;
+        if (!breakdown) {
+            this.logger?.warn(`Completed plan_breakdown task ${task.id} did not return a structured breakdown result.`);
+            return;
+        }
+        const repo = this.reposById.get(task.repoId);
+        const targetNumber = Task.from(task).owningThreadNumber();
+        if (!repo || targetNumber === undefined) {
+            this.logger?.warn(`Could not resolve repo or target number for plan_breakdown task ${task.id}.`);
+            return;
+        }
+        await this.gitHubGateway.postIssueComment({
+            owner: repo.owner,
+            name: repo.name,
+            issueNumber: targetNumber,
+            body: renderPlanBreakdownComment(breakdown)
+        });
+    }
+}
+export function renderPlanBreakdownComment(result) {
+    const lines = ["🤖 Breakdown recommendation", ""];
+    lines.push("## Summary", "", result.summary, "");
+    lines.push("## Dependency graph", "");
+    lines.push("| Task ID | Title | Depends on | Blocks | Parallel with | Risk |");
+    lines.push("| --- | --- | --- | --- | --- | --- |");
+    for (const task of result.tasks) {
+        const row = [
+            task.id,
+            escapeTableCell(task.title),
+            formatInlineList(task.dependsOn),
+            formatInlineList(task.blocks),
+            formatInlineList(task.canRunInParallelWith),
+            task.risk
+        ];
+        lines.push(`| ${row.join(" | ")} |`);
+    }
+    lines.push("");
+    lines.push("## Execution waves", "");
+    for (const wave of result.waves) {
+        lines.push(`### Wave ${wave.id}`, "", wave.rationale, "");
+        for (const taskId of wave.taskIds) {
+            const task = result.tasks.find((t) => t.id === taskId);
+            if (task) {
+                lines.push(`- ${task.id}: ${task.title}`);
+            }
+        }
+        lines.push("");
+    }
+    lines.push("## Recommended first wave", "", result.recommendedFirstWaveId, "");
+    lines.push("## Staged implementation packets", "");
+    for (const task of result.tasks) {
+        lines.push(`### ${task.id}: ${task.title}`, "", task.description, "");
+        lines.push(`- **Depends on:** ${formatInlineList(task.dependsOn)}`);
+        lines.push(`- **Blocks:** ${formatInlineList(task.blocks)}`);
+        lines.push(`- **Parallel with:** ${formatInlineList(task.canRunInParallelWith)}`);
+        lines.push(`- **Risk:** ${task.risk}`);
+        lines.push(`- **Files likely involved:** ${formatInlineList(task.filesLikelyInvolved)}`);
+        lines.push("- **Acceptance criteria:**");
+        lines.push(formatBulletList(task.acceptanceCriteria));
+        lines.push("- **Verification:**");
+        lines.push(formatBulletList(task.verification));
+        lines.push("");
+    }
+    lines.push("## Graph concerns / uncertainty", "");
+    lines.push(formatBulletList(result.graphConcerns));
+    lines.push("");
+    lines.push("## Human decisions needed", "");
+    lines.push(formatBulletList(result.humanDecisionsNeeded));
+    lines.push("");
+    lines.push("## Suggested next action", "", result.suggestedNextAction);
+    return lines.join("\n").trim();
+}
+function formatInlineList(values) {
+    return values.length > 0 ? values.join(", ") : "-";
+}
+function formatBulletList(values, emptyText = "None") {
+    if (values.length === 0)
+        return `  - ${emptyText}`;
+    return values.map((v) => `  - ${v}`).join("\n");
+}
+function escapeTableCell(value) {
+    return value.replace(/\|/g, "\\|").replace(/\n/g, " ");
+}