@h-rig/cli 0.0.6-alpha.0

package/dist/src/commands/task-report-bug.js

@@ -0,0 +1,1083 @@
+// @bun
+// packages/cli/src/commands/task-report-bug.ts
+import { existsSync as existsSync2, readFileSync, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve3 } from "path";
+import * as clack from "@clack/prompts";
+import pc from "picocolors";
+
+// packages/cli/src/runner.ts
+import { EventBus } from "@rig/runtime/control-plane/runtime/events";
+import { CliError } from "@rig/runtime/control-plane/errors";
+import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
+import { PluginManager } from "@rig/runtime/control-plane/runtime/plugins";
+import { loadRuntimeContextFromEnv } from "@rig/runtime/control-plane/runtime/context";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+import { CliError as CliError2 } from "@rig/runtime/control-plane/errors";
+function formatCommand(parts) {
+  return parts.map((part) => /[^a-zA-Z0-9_./:-]/.test(part) ? JSON.stringify(part) : part).join(" ");
+}
+function takeFlag(args, flag) {
+  const rest = [];
+  let value = false;
+  for (const arg of args) {
+    if (arg === flag) {
+      value = true;
+      continue;
+    }
+    rest.push(arg);
+  }
+  return { value, rest };
+}
+function takeOption(args, option) {
+  const rest = [];
+  let value;
+  for (let index = 0;index < args.length; index += 1) {
+    const current = args[index];
+    if (current === option) {
+      const next = args[index + 1];
+      if (!next || next.startsWith("-")) {
+        throw new CliError(`Missing value for ${option}`);
+      }
+      value = next;
+      index += 1;
+      continue;
+    }
+    if (current !== undefined) {
+      rest.push(current);
+    }
+  }
+  return { value, rest };
+}
+function requireNoExtraArgs(args, usage) {
+  if (args.length > 0) {
+    throw new CliError(`Unexpected arguments: ${args.join(" ")}
+Usage: ${usage}`);
+  }
+}
+
+// packages/cli/src/commands/task-report-bug.ts
+import {
+  appendJsonlRecord,
+  readJsonFile,
+  readJsonlFile,
+  writeJsonFile
+} from "@rig/runtime/control-plane/authority-files";
+import { runCapture, unique } from "@rig/runtime/control-plane/native/utils";
+
+// packages/cli/src/commands/_paths.ts
+import { resolve } from "path";
+import { resolveMonorepoRoot } from "@rig/runtime/control-plane/native/utils";
+function resolveControlPlaneMonorepoRoot(projectRoot) {
+  return resolveMonorepoRoot(projectRoot);
+}
+function resolveControlPlaneTaskConfigPath(projectRoot) {
+  return resolve(resolveControlPlaneMonorepoRoot(projectRoot), ".rig", "task-config.json");
+}
+
+// packages/cli/src/report-bug.ts
+import { copyFileSync, existsSync, mkdirSync, rmSync, writeFileSync } from "fs";
+import { basename, extname, join, resolve as resolve2 } from "path";
+function slugifyBugTitle(value) {
+  const slug = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80).replace(/-+$/g, "");
+  return slug || "bug-report";
+}
+function defaultBrowserBugProfile(title) {
+  return `hp-next-${slugifyBugTitle(title)}`;
+}
+function defaultBrowserBugOptions(environment) {
+  if (environment === "shared-dev") {
+    return {
+      preset: "hp-next-shared",
+      attachUrl: "http://127.0.0.1:9341",
+      stateDir: ".tmp/rig-browser/hp-next-shared"
+    };
+  }
+  return {
+    preset: "hp-next-local",
+    attachUrl: "http://127.0.0.1:9333",
+    stateDir: ".tmp/rig-browser/hp-next"
+  };
+}
+function createBugReportFiles(input) {
+  const slug = slugifyBugTitle(input.slug || input.title);
+  const outputDir = resolve2(input.projectRoot, input.outputRoot);
+  const reportDir = resolve2(outputDir, slug);
+  const assetDir = join(reportDir, "assets");
+  const screenshotDir = join(reportDir, "screenshots");
+  const taskPath = join(reportDir, "task.md");
+  const browserRequired = input.browserRequired ?? true;
+  const browserPath = browserRequired ? join(reportDir, "browser.json") : null;
+  const manifestPath = join(reportDir, "manifest.json");
+  if (existsSync(reportDir)) {
+    if (!input.overwrite) {
+      throw new Error(`Bug report directory already exists: ${reportDir}`);
+    }
+    rmSync(reportDir, { recursive: true, force: true });
+  }
+  mkdirSync(assetDir, { recursive: true });
+  mkdirSync(screenshotDir, { recursive: true });
+  const copiedScreenshots = copyEvidenceFiles(input.projectRoot, screenshotDir, input.screenshots ?? [], "screenshot");
+  const copiedAssets = copyEvidenceFiles(input.projectRoot, assetDir, input.assets ?? [], "asset");
+  const manifestAssets = [
+    ...copiedScreenshots.map((name) => ({
+      path: `screenshots/${name}`,
+      type: mediaTypeForFileName(name)
+    })),
+    ...copiedAssets.map((name) => ({
+      path: `assets/${name}`,
+      type: mediaTypeForFileName(name)
+    }))
+  ];
+  const browser = browserRequired ? buildBrowserBlock(input) : null;
+  const manifest = {
+    schema_version: 1,
+    slug,
+    issue_id: input.issueId ?? null,
+    title: input.title,
+    environment: input.environment,
+    url: input.url,
+    viewport: input.viewport,
+    task_file: "task.md",
+    browser_file: browserRequired ? "browser.json" : null,
+    screenshots: copiedScreenshots.map((name) => `screenshots/${name}`),
+    assets: manifestAssets,
+    created_at: new Date().toISOString(),
+    platform: process.platform,
+    arch: process.arch
+  };
+  writeFileSync(join(assetDir, "README.md"), buildAssetReadme(input.title), "utf8");
+  writeFileSync(join(screenshotDir, "README.md"), buildScreenshotReadme(input.title), "utf8");
+  if (browserPath && browser) {
+    writeFileSync(browserPath, `${JSON.stringify(browser, null, 2)}
+`, "utf8");
+  }
+  writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+  writeFileSync(taskPath, buildBugReportMarkdown(input, browser, copiedScreenshots, copiedAssets), "utf8");
+  return {
+    slug,
+    reportDir,
+    taskPath,
+    browserPath,
+    manifestPath,
+    assetDir,
+    screenshotDir,
+    copiedAssets,
+    copiedScreenshots
+  };
+}
+function buildBrowserBlock(input) {
+  return {
+    browser: {
+      required: true,
+      preset: input.preset,
+      profile: input.profile,
+      attach_url: input.attachUrl,
+      state_dir: input.stateDir,
+      dev_command: "bun run app:dev:browser:hp-next",
+      launch_command: "bun run app:start:browser:hp-next",
+      check_command: "bun run app:check:browser:hp-next",
+      e2e_command: "bun run app:e2e:browser:hp-next",
+      mode: input.mode
+    }
+  };
+}
+function buildBugReportMarkdown(input, browser, screenshots, assets) {
+  const browserRequired = input.browserRequired ?? true;
+  const assetEntries = [
+    ...screenshots.map((name) => ({ name, path: `screenshots/${name}` })),
+    ...assets.map((name) => ({ name, path: `assets/${name}` }))
+  ];
+  const assetLines = assetEntries.length > 0 ? assetEntries.map(({ name, path }) => formatAssetMarkdown(name, path)) : ["- No assets attached yet. Drag screenshots or videos into `assets/` and link them here."];
+  const evidenceLines = input.evidence.length > 0 ? input.evidence.map((item) => `- ${item}`) : ["- Console errors: not captured yet.", "- Failed network requests: not captured yet."];
+  return [
+    `# ${input.title}`,
+    "",
+    ...input.issueId ? ["## Task", "", `Task ID: \`${input.issueId}\``, ""] : [],
+    "## Summary",
+    "",
+    input.summary || "TODO: describe the user-visible bug.",
+    "",
+    ...browser ? [
+      "## Browser Block",
+      "",
+      "```json",
+      JSON.stringify(browser, null, 2),
+      "```",
+      ""
+    ] : [],
+    "## Environment",
+    "",
+    `- URL: \`${input.url}\``,
+    `- Environment: \`${input.environment}\``,
+    ...browserRequired ? [
+      `- Preset: \`${input.preset}\``,
+      `- Profile: \`${input.profile}\``,
+      `- Viewport: \`${input.viewport}\``
+    ] : ["- Browser: not required for this report."],
+    "",
+    "## Reproduction",
+    "",
+    ...numberedLines(input.steps.length > 0 ? input.steps : ["TODO: add reproduction step."]),
+    "",
+    "## Expected",
+    "",
+    input.expected || "TODO: expected behavior.",
+    "",
+    "## Actual",
+    "",
+    input.actual || "TODO: actual behavior.",
+    "",
+    "## Assets",
+    "",
+    ...assetLines,
+    "",
+    "## Evidence",
+    "",
+    ...evidenceLines,
+    "",
+    "## Agent Handoff",
+    "",
+    ...input.issueId ? [
+      `- Canonical task assets live under \`artifacts/${input.issueId}/bug-report/\`.`,
+      `- Start with \`artifacts/${input.issueId}/bug-report/task.md\` and the files in \`artifacts/${input.issueId}/bug-report/assets/\`.`,
+      browserRequired ? `- Run \`bun run rig task info --task ${input.issueId}\` to confirm browser wiring before debugging.` : `- Run \`bun run rig task info --task ${input.issueId}\` to confirm scope and artifact links before debugging.`
+    ] : [
+      "- Draft-only report: convert this into a beads task before assigning it to an agent run."
+    ],
+    "",
+    "## Validation",
+    "",
+    "```bash",
+    ...input.issueId ? [`bun run rig task validate --task ${input.issueId}`] : [],
+    ...browserRequired ? [
+      "bun run app:check:browser:hp-next",
+      "bun run app:e2e:browser:hp-next"
+    ] : [],
+    "```",
+    ""
+  ].join(`
+`);
+}
+function numberedLines(items) {
+  return items.map((item, index) => `${index + 1}. ${item}`);
+}
+function buildAssetReadme(title) {
+  return [
+    `# Evidence Assets For ${title}`,
+    "",
+    "Drag and drop screenshots or videos for this bug report into this directory.",
+    "Use stable, descriptive file names such as `login-loading.png`, `chunk-404-network.png`, or `otp-flow.webm`.",
+    "Reference images from `../task.md` with Markdown image links and videos with normal file links.",
+    ""
+  ].join(`
+`);
+}
+function buildScreenshotReadme(title) {
+  return [
+    `# Screenshots For ${title}`,
+    "",
+    "Drop legacy screenshot files for this bug report into this directory.",
+    "Use `assets/` for new screenshot, video, and mixed evidence attachments.",
+    "Reference screenshots from `../task.md` with Markdown image links.",
+    ""
+  ].join(`
+`);
+}
+function copyEvidenceFiles(projectRoot, targetDir, paths, label) {
+  const copied = [];
+  const used = new Set;
+  for (const rawPath of paths.map((path) => path.trim()).filter(Boolean)) {
+    const source = resolve2(projectRoot, rawPath);
+    if (!existsSync(source)) {
+      throw new Error(`${label} does not exist: ${source}`);
+    }
+    const targetName = uniqueEvidenceName(rawPath, used, label);
+    copyFileSync(source, join(targetDir, targetName));
+    copied.push(targetName);
+  }
+  return copied;
+}
+function uniqueEvidenceName(path, used, fallback) {
+  const original = sanitizeFileName(basename(path)) || fallback;
+  const extension = extname(original);
+  const stem = extension ? original.slice(0, -extension.length) : original;
+  let candidate = original;
+  let index = 2;
+  while (used.has(candidate)) {
+    candidate = `${stem}-${index}${extension}`;
+    index += 1;
+  }
+  used.add(candidate);
+  return candidate;
+}
+function sanitizeFileName(value) {
+  return value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function mediaTypeForFileName(fileName) {
+  const extension = extname(fileName).toLowerCase();
+  if ([".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg"].includes(extension)) {
+    return "image";
+  }
+  if ([".mp4", ".mov", ".m4v", ".webm", ".avi", ".mkv"].includes(extension)) {
+    return "video";
+  }
+  return "file";
+}
+function formatAssetMarkdown(name, path) {
+  return mediaTypeForFileName(name) === "image" ? `- ![${name}](${path})` : `- [${name}](${path})`;
+}
+
+// packages/cli/src/commands/task-report-bug.ts
+var BROWSER_BUG_REPORT_VALIDATION = "integration:browser-bug-report-task";
+function shouldColorizeCliOutput() {
+  return Boolean(process.stdout.isTTY) && process.env.NO_COLOR === undefined && process.env.TERM !== "dumb";
+}
+async function executeTaskReportBug(context, args) {
+  let pending = args;
+  const noPromptFlag = takeFlag(pending, "--no-prompt");
+  pending = noPromptFlag.rest;
+  const noBeadsFlag = takeFlag(pending, "--no-beads");
+  pending = noBeadsFlag.rest;
+  const browserFlag = takeFlag(pending, "--browser");
+  pending = browserFlag.rest;
+  const noBrowserFlag = takeFlag(pending, "--no-browser");
+  pending = noBrowserFlag.rest;
+  if (browserFlag.value && noBrowserFlag.value) {
+    throw new CliError2("Pass only one of --browser or --no-browser.");
+  }
+  const overwriteFlag = takeFlag(pending, "--overwrite");
+  pending = overwriteFlag.rest;
+  const titleResult = takeOption(pending, "--title");
+  pending = titleResult.rest;
+  const urlResult = takeOption(pending, "--url");
+  pending = urlResult.rest;
+  const environmentResult = takeOption(pending, "--environment");
+  pending = environmentResult.rest;
+  const presetResult = takeOption(pending, "--preset");
+  pending = presetResult.rest;
+  const profileResult = takeOption(pending, "--profile");
+  pending = profileResult.rest;
+  const attachUrlResult = takeOption(pending, "--attach-url");
+  pending = attachUrlResult.rest;
+  const stateDirResult = takeOption(pending, "--state-dir");
+  pending = stateDirResult.rest;
+  const modeResult = takeOption(pending, "--mode");
+  pending = modeResult.rest;
+  const viewportResult = takeOption(pending, "--viewport");
+  pending = viewportResult.rest;
+  const summaryResult = takeOption(pending, "--summary");
+  pending = summaryResult.rest;
+  const stepsResult = takeOption(pending, "--steps");
+  pending = stepsResult.rest;
+  const expectedResult = takeOption(pending, "--expected");
+  pending = expectedResult.rest;
+  const actualResult = takeOption(pending, "--actual");
+  pending = actualResult.rest;
+  const evidenceResult = takeOption(pending, "--evidence");
+  pending = evidenceResult.rest;
+  const priorityResult = takeOption(pending, "--priority");
+  pending = priorityResult.rest;
+  const labelsResult = takeOption(pending, "--labels");
+  pending = labelsResult.rest;
+  const parentResult = takeOption(pending, "--parent");
+  pending = parentResult.rest;
+  const assigneeResult = takeOption(pending, "--assignee");
+  pending = assigneeResult.rest;
+  const ownerResult = takeOption(pending, "--owner");
+  pending = ownerResult.rest;
+  const screenshotResult = takeRepeatedOption(pending, "--screenshot");
+  pending = screenshotResult.rest;
+  const assetResult = takeRepeatedOption(pending, "--asset");
+  pending = assetResult.rest;
+  const videoResult = takeRepeatedOption(pending, "--video");
+  pending = videoResult.rest;
+  const outputRootResult = takeOption(pending, "--output-dir");
+  pending = outputRootResult.rest;
+  const slugResult = takeOption(pending, "--slug");
+  pending = slugResult.rest;
+  requireNoExtraArgs(pending, "bun run rig report-bug [--no-prompt] [--no-beads] [--browser|--no-browser] --title <text> --url <url> [--asset <dragged-file>]");
+  let draft = {
+    outputRoot: outputRootResult.value || "",
+    title: titleResult.value,
+    url: urlResult.value,
+    browserRequired: !noBrowserFlag.value,
+    environment: environmentResult.value || "local",
+    preset: presetResult.value,
+    profile: profileResult.value,
+    attachUrl: attachUrlResult.value,
+    stateDir: stateDirResult.value,
+    mode: modeResult.value || "persistent",
+    viewport: viewportResult.value || "1440x900",
+    summary: summaryResult.value,
+    steps: splitPromptList(stepsResult.value),
+    expected: expectedResult.value,
+    actual: actualResult.value,
+    evidence: splitPromptList(evidenceResult.value),
+    priority: priorityResult.value || "P2",
+    labels: splitLabelList(labelsResult.value),
+    parent: parentResult.value,
+    assignee: assigneeResult.value,
+    owner: ownerResult.value,
+    screenshots: screenshotResult.values.flatMap(splitCliAssetOption),
+    assets: [...assetResult.values, ...videoResult.values].flatMap(splitCliAssetOption),
+    slug: slugResult.value,
+    overwrite: overwriteFlag.value,
+    createBeadsTask: !noBeadsFlag.value
+  };
+  const shouldPrompt = !noPromptFlag.value;
+  if (shouldPrompt) {
+    if (context.outputMode !== "text" || !process.stdin.isTTY || !process.stdout.isTTY) {
+      throw new CliError2("Interactive bug reporting requires a TTY in text mode. Pass --no-prompt with flags for automation.");
+    }
+    draft = await promptForBugReportDetails(draft);
+  }
+  const title = requireReportBugValue(draft.title, "--title");
+  const url = requireReportBugValue(draft.url, "--url");
+  const defaults = defaultBrowserBugOptions(draft.environment);
+  const profile = draft.profile || defaultBrowserBugProfile(title);
+  const baseInput = {
+    projectRoot: context.projectRoot,
+    outputRoot: draft.outputRoot || "docs/bug-reports",
+    title,
+    url,
+    browserRequired: draft.browserRequired,
+    environment: draft.environment,
+    preset: draft.preset || defaults.preset,
+    profile,
+    attachUrl: draft.attachUrl || defaults.attachUrl,
+    stateDir: draft.stateDir || defaults.stateDir,
+    mode: draft.mode,
+    viewport: draft.viewport,
+    summary: draft.summary || "TODO: describe the user-visible bug.",
+    steps: draft.steps,
+    expected: draft.expected || "TODO: expected behavior.",
+    actual: draft.actual || "TODO: actual behavior.",
+    evidence: draft.evidence,
+    screenshots: resolveBugReportDroppedFiles(context.projectRoot, draft.screenshots),
+    assets: resolveBugReportDroppedFiles(context.projectRoot, draft.assets),
+    slug: draft.slug,
+    overwrite: draft.overwrite
+  };
+  validateBugReportInputFiles(baseInput);
+  if (context.dryRun) {
+    const slug = draft.createBeadsTask ? "<new-task-id>/bug-report" : slugifyBugTitle(baseInput.slug || baseInput.title);
+    const reportDir = draft.createBeadsTask ? resolve3(resolveControlPlaneMonorepoRoot(context.projectRoot), "artifacts", slug) : resolve3(context.projectRoot, baseInput.outputRoot, slug);
+    if (context.outputMode === "text") {
+      console.log(draft.createBeadsTask ? `Would create beads task and assets: ${reportDir}` : `Would create bug report: ${reportDir}`);
+    }
+    return {
+      ok: true,
+      group: "task",
+      command: "report-bug",
+      details: { dryRun: true, slug, reportDir }
+    };
+  }
+  const monorepoRoot = draft.createBeadsTask ? resolveControlPlaneMonorepoRoot(context.projectRoot) : null;
+  const issueCreation = monorepoRoot ? createBugReportBeadsTask(monorepoRoot, baseInput, draft) : null;
+  const issueId = issueCreation?.issueId ?? null;
+  const input = {
+    ...baseInput,
+    projectRoot: monorepoRoot ?? context.projectRoot,
+    outputRoot: issueId ? `artifacts/${issueId}` : baseInput.outputRoot,
+    slug: issueId ? "bug-report" : baseInput.slug,
+    issueId: issueId ?? undefined
+  };
+  const result = createBugReportFiles(input);
+  const reportRelativePath = issueId ? `artifacts/${issueId}/bug-report/task.md` : null;
+  const taskConfigPath = issueId ? upsertBugReportTaskConfig(context.projectRoot, issueId, input, reportRelativePath) : null;
+  if (issueCreation && monorepoRoot && reportRelativePath) {
+    updateBugReportBeadsTask(monorepoRoot, issueCreation, readFileSync(result.taskPath, "utf8"), reportRelativePath, input);
+  }
+  if (context.outputMode === "text") {
+    console.log(issueId ? `Bug task created: ${issueId}` : "Draft bug report created");
+    console.log(`Bug report assets: ${result.reportDir}`);
+    console.log(`Task: ${result.taskPath}`);
+    if (result.browserPath) {
+      console.log(`Browser block: ${result.browserPath}`);
+    } else {
+      console.log("Browser block: not requested");
+    }
+    console.log(`Evidence assets: ${result.assetDir}`);
+    if (taskConfigPath) {
+      console.log(`Task config: ${taskConfigPath}`);
+      console.log(`Run: bun run rig task info --task ${issueId}`);
+    }
+  }
+  return {
+    ok: true,
+    group: "task",
+    command: "report-bug",
+    details: {
+      slug: result.slug,
+      issueId,
+      reportDir: result.reportDir,
+      taskPath: result.taskPath,
+      browserPath: result.browserPath,
+      manifestPath: result.manifestPath,
+      assetDir: result.assetDir,
+      assets: result.copiedAssets,
+      screenshotDir: result.screenshotDir,
+      screenshots: result.copiedScreenshots,
+      taskConfigPath,
+      taskRecordBackend: issueCreation?.backend ?? null
+    }
+  };
+}
+function validateBugReportInputFiles(input) {
+  const files = [
+    ...(input.screenshots ?? []).map((path) => ({ path, label: "Screenshot" })),
+    ...(input.assets ?? []).map((path) => ({ path, label: "Asset" }))
+  ];
+  for (const { path, label } of files.map((item) => ({ ...item, path: item.path.trim() })).filter((item) => item.path)) {
+    const source = resolve3(input.projectRoot, path);
+    if (!existsSync2(source)) {
+      throw new CliError2(`${label} does not exist: ${source}`);
+    }
+  }
+}
+function resolveBugReportDroppedFiles(projectRoot, paths) {
+  return paths.map((path) => {
+    const trimmed = path.trim();
+    return trimmed ? resolve3(projectRoot, trimmed) : trimmed;
+  });
+}
+function createBugReportBeadsTask(monorepoRoot, input, draft) {
+  const labels = buildBugReportLabels(input, draft);
+  const priority = normalizeBugReportPriority(draft.priority);
+  const command = [
+    "br",
+    "create",
+    "--title",
+    input.title,
+    "--type",
+    "task",
+    "--priority",
+    priority,
+    "--description",
+    buildInitialBugReportDescription(input),
+    "--labels",
+    labels.join(","),
+    "--json"
+  ];
+  if (draft.parent?.trim()) {
+    command.push("--parent", draft.parent.trim());
+  }
+  if (draft.assignee?.trim()) {
+    command.push("--assignee", draft.assignee.trim());
+  }
+  if (draft.owner?.trim()) {
+    command.push("--owner", draft.owner.trim());
+  }
+  const issue = tryRunBrJson(monorepoRoot, command);
+  if (!issue.ok) {
+    if (!isRecoverableBeadsJsonlFailure(issue.error)) {
+      throw new CliError2(issue.error);
+    }
+    return {
+      issueId: generateBugReportIssueId(monorepoRoot, input.title),
+      backend: "jsonl",
+      labels,
+      priority
+    };
+  }
+  const issueId = issue.value.id?.trim();
+  if (!issueId) {
+    throw new CliError2("br create did not return an issue id.");
+  }
+  return {
+    issueId,
+    backend: "br",
+    labels,
+    priority
+  };
+}
+function updateBugReportBeadsTask(monorepoRoot, issueCreation, taskMarkdown, externalRef, input) {
+  if (issueCreation.backend === "jsonl") {
+    appendBugReportJsonlTask(monorepoRoot, issueCreation, taskMarkdown, externalRef, input);
+    return;
+  }
+  runBrJson(monorepoRoot, [
+    "br",
+    "update",
+    issueCreation.issueId,
+    "--description",
+    taskMarkdown,
+    "--acceptance-criteria",
+    buildBugReportAcceptanceCriteria(input),
+    "--external-ref",
+    externalRef,
+    "--json"
+  ]);
+}
+function appendBugReportJsonlTask(monorepoRoot, issueCreation, taskMarkdown, externalRef, input) {
+  const now = new Date().toISOString();
+  appendJsonlRecord(resolve3(monorepoRoot, ".beads", "issues.jsonl"), {
+    id: issueCreation.issueId,
+    title: input.title,
+    description: taskMarkdown,
+    acceptance_criteria: buildBugReportAcceptanceCriteria(input),
+    status: "open",
+    priority: priorityToNumber(issueCreation.priority),
+    issue_type: "task",
+    created_at: now,
+    created_by: process.env.USER || process.env.USERNAME || "rig",
+    updated_at: now,
+    external_ref: externalRef,
+    source_repo: ".",
+    compaction_level: 0,
+    original_size: 0,
+    labels: issueCreation.labels
+  });
+}
+function upsertBugReportTaskConfig(projectRoot, issueId, input, reportRelativePath) {
+  const taskConfigPath = resolveControlPlaneTaskConfigPath(projectRoot);
+  const browserRequired = input.browserRequired ?? true;
+  const entry = {
+    description: [
+      "Browser bug report generated by `rig report-bug`.",
+      "",
+      `Canonical report: \`${reportRelativePath}\``
+    ].join(`
+`),
+    acceptance_criteria: buildBugReportAcceptanceCriteria(input),
+    scope: [
+      `artifacts/${issueId}/bug-report/**`,
+      "hp-next/**",
+      "microservices/hp-next-frontend/**",
+      "humoongate/humanity/hp-next/**"
+    ],
+    role: "verifier",
+    criticality: "normal"
+  };
+  if (browserRequired) {
+    entry.browser = {
+      required: true,
+      preset: input.preset,
+      profile: input.profile,
+      attach_url: input.attachUrl,
+      state_dir: input.stateDir,
+      dev_command: "bun run app:dev:browser:hp-next",
+      launch_command: "bun run app:start:browser:hp-next",
+      check_command: "bun run app:check:browser:hp-next",
+      e2e_command: "bun run app:e2e:browser:hp-next",
+      mode: input.mode
+    };
+    entry.validation = [BROWSER_BUG_REPORT_VALIDATION];
+  }
+  appendTaskConfigEntryPreservingText(taskConfigPath, issueId, entry);
+  return taskConfigPath;
+}
+function appendTaskConfigEntryPreservingText(taskConfigPath, issueId, entry) {
+  const raw = existsSync2(taskConfigPath) ? readFileSync(taskConfigPath, "utf8") : `{}
+`;
+  if (raw.includes(`"${issueId}"`)) {
+    const parsed = readJsonFile(taskConfigPath, {});
+    parsed[issueId] = entry;
+    writeJsonFile(taskConfigPath, parsed);
+    return;
+  }
+  const trimmed = raw.trim();
+  const serializedEntry = `${JSON.stringify(issueId)}: ${JSON.stringify(entry, null, 2)}`.split(`
+`).map((line) => `  ${line}`).join(`
+`);
+  if (!trimmed || trimmed === "{}") {
+    writeFileSync2(taskConfigPath, `{
+${serializedEntry}
+}
+`, "utf8");
+    return;
+  }
+  const insertAt = raw.lastIndexOf("}");
+  if (insertAt < 0) {
+    throw new CliError2(`Invalid task config JSON object: ${taskConfigPath}`);
+  }
+  const before = raw.slice(0, insertAt).replace(/\s*$/, "");
+  const after = raw.slice(insertAt + 1).trim();
+  if (after) {
+    throw new CliError2(`Invalid trailing content in task config: ${taskConfigPath}`);
+  }
+  const comma = before.trim() === "{" ? "" : ",";
+  writeFileSync2(taskConfigPath, `${before}${comma}
+${serializedEntry}
+}
+`, "utf8");
+}
+function buildBugReportLabels(input, draft) {
+  return unique([
+    "bug",
+    "bug-report",
+    ...input.browserRequired === false ? [] : ["browser-required"],
+    "hp-next",
+    `env:${input.environment}`,
+    "role:verifier",
+    ...draft.labels
+  ].map(sanitizeBugReportLabel).filter(Boolean));
+}
+function buildInitialBugReportDescription(input) {
+  return [
+    input.summary || "Browser bug report generated by `rig report-bug`.",
+    "",
+    "The detailed task assets are written after task creation under `artifacts/<task-id>/bug-report/`."
+  ].join(`
+`);
+}
+function buildBugReportAcceptanceCriteria(input) {
+  if (input.browserRequired === false) {
+    return [
+      "1. Reproduce the bug using the provided steps and task assets.",
+      "2. Fix the underlying product or server issue without removing the reported user flow.",
+      "3. Preserve all provided task assets and evidence in the task artifact directory.",
+      `4. Verify the target URL or endpoint behaves correctly: ${input.url}`,
+      "5. Run the generated task validation when available, or document the manual verification performed."
+    ].join(`
+`);
+  }
+  return [
+    "1. Reproduce the bug with Rig Browser using the browser block in the task assets.",
+    "2. Fix the underlying product or server issue without removing the reported user flow.",
+    "3. Preserve all provided screenshots and evidence in the task artifact directory.",
+    `4. Verify the target URL renders correctly: ${input.url}`,
+    "5. Run the generated task validation plus `bun run app:check:browser:hp-next` and `bun run app:e2e:browser:hp-next`, or document why either browser command cannot run."
+  ].join(`
+`);
+}
+function normalizeBugReportPriority(priority) {
+  const normalized = priority.trim().toUpperCase();
+  return /^P?[0-4]$/.test(normalized) ? normalized : "P2";
+}
+function priorityToNumber(priority) {
+  const normalized = normalizeBugReportPriority(priority).replace(/^P/, "");
+  return Number.parseInt(normalized, 10);
+}
+function sanitizeBugReportLabel(label) {
+  return label.trim().toLowerCase().replace(/\s+/g, "-");
+}
+function generateBugReportIssueId(monorepoRoot, title) {
+  const existingIds = new Set(readJsonlFile(resolve3(monorepoRoot, ".beads", "issues.jsonl")).filter((entry) => !!entry && typeof entry === "object").map((entry) => entry.id).filter((id) => typeof id === "string" && id.trim().length > 0));
+  const base = slugifyBugTitle(title).replace(/-/g, "").slice(0, 8) || "bug";
+  for (let attempt = 0;attempt < 10; attempt += 1) {
+    const suffix = `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+    const id = `bd-${base}-${suffix}`.slice(0, 48);
+    if (!existingIds.has(id)) {
+      return id;
+    }
+  }
+  throw new CliError2("Could not generate a unique bug task id.");
+}
+function isRecoverableBeadsJsonlFailure(message) {
+  return /Invalid JSON|missing field|JSONL is newer than DB|stale database/i.test(message);
+}
+function runBrJson(cwd, command) {
+  const result = tryRunBrJson(cwd, command);
+  if (!result.ok) {
+    throw new CliError2(result.error);
+  }
+  return result.value;
+}
+function tryRunBrJson(cwd, command) {
+  const result = runCapture(command, cwd);
+  if (result.exitCode !== 0) {
+    const detail = [result.stderr.trim(), result.stdout.trim()].filter(Boolean).join(`
+`);
+    return {
+      ok: false,
+      error: `beads command failed: ${formatCommand(command)}${detail ? `
+${detail}` : ""}`
+    };
+  }
+  try {
+    return { ok: true, value: JSON.parse(result.stdout) };
+  } catch (error) {
+    return {
+      ok: false,
+      error: `beads command did not return JSON: ${formatCommand(command)}
+${result.stdout.trim() || String(error)}`
+    };
+  }
+}
+async function promptForBugReportDetails(initial) {
+  clack.intro("rig report-bug");
+  clack.note([
+    "Creates an agent-ready issue with copied evidence files.",
+    "When prompted for assets, drag screenshots/videos into the terminal and press Enter."
+  ].join(`
+`), "Bug report wizard");
+  clack.log.step("1/5 Incident");
+  clack.note(bugPromptExampleText("incident"), "Input examples");
+  const title = await promptBugText("Bug title", initial.title, {
+    required: true,
+    placeholder: "Login page never leaves loading"
+  });
+  const url = await promptBugText("URL to reproduce", initial.url, {
+    required: true,
+    placeholder: "https://dev.rig.hptestingsite.com/login?next=%2F"
+  });
+  const environmentChoice = await promptBugSelect("Environment", [
+    { value: "local", label: "local", hint: "local hp-next / service fabric" },
+    { value: "shared-dev", label: "shared-dev", hint: "shared deployed dev surface" },
+    { value: "staging", label: "staging" },
+    { value: "production", label: "production" },
+    { value: "custom", label: "custom", hint: "enter a custom environment name" }
+  ], normalizeBugEnvironmentChoice(initial.environment));
+  const environment = environmentChoice === "custom" ? await promptBugText("Custom environment", ["local", "shared-dev", "staging", "production", "custom"].includes(initial.environment) ? undefined : initial.environment, { required: true, placeholder: "qa-dev" }) : environmentChoice;
+  const defaults = defaultBrowserBugOptions(environment);
+  const summary = await promptBugText("Short summary", initial.summary, {
+    placeholder: "Email field never appears after navigating from credentials."
+  });
+  clack.log.step("2/5 Reproduction");
+  clack.note(bugPromptExampleText("reproduction"), "Input examples");
+  const steps = splitPromptList(await promptBugText("Repro steps (semicolon-separated)", initial.steps.join("; "), {
+    placeholder: "Open /login; Enter qa@example.com; Press Continue"
+  }));
+  const expected = await promptBugText("Expected behavior", initial.expected, {
+    placeholder: "OTP form is visible and accepts a code."
+  });
+  const actual = await promptBugText("Actual behavior", initial.actual, {
+    placeholder: "Loading shell stays forever."
+  });
+  clack.log.step("3/5 Evidence");
+  clack.note(bugPromptExampleText("evidence"), "Input examples");
+  const evidence = splitPromptList(await promptBugText("Evidence notes (console/network/API; semicolon-separated)", initial.evidence.join("; "), {
+    placeholder: "Console: ChunkLoadError for credentials route; Network: /assets/app.js 404"
+  }));
+  const assets = splitDroppedAssetList(await promptBugText("Drag screenshots/videos here (Enter to skip)", initial.assets.map(formatDroppedAssetDefault).join(" "), { placeholder: "/Users/me/Desktop/login-loading.png /Users/me/Desktop/otp-flow.webm" }));
+  clack.log.step("4/5 Routing");
+  clack.note(bugPromptExampleText("routing"), "Input examples");
+  const priority = await promptBugSelect("Priority", [
+    { value: "P0", label: "P0", hint: "urgent / blocking" },
+    { value: "P1", label: "P1", hint: "high" },
+    { value: "P2", label: "P2", hint: "normal default" },
+    { value: "P3", label: "P3", hint: "low" },
+    { value: "P4", label: "P4", hint: "backlog" }
+  ], normalizeBugReportPriority(initial.priority || "P2"));
+  const labels = splitLabelList(await promptBugText("Extra labels, comma- or semicolon-separated", initial.labels.join(", "), {
+    placeholder: "auth, otp, hp-next"
+  }));
+  const parent = await promptBugText("Parent task or epic id (optional)", initial.parent, {
+    placeholder: "bd-auth-epic-123"
+  });
+  clack.log.step("5/5 Browser");
+  clack.note(bugPromptExampleText("browser"), "Input examples");
+  const browserRequired = await promptBugConfirm("Does this task need Rig Browser wiring?", initial.browserRequired);
+  let viewport = initial.viewport || "1440x900";
+  let profile = initial.profile;
+  if (browserRequired) {
+    clack.note([
+      "A profile is the browser state bucket: cookies, localStorage, auth session, and cache.",
+      "Use a bug-specific profile for clean login/OTP runs; use a shared profile only when saved auth matters."
+    ].join(`
+`), "Rig Browser profile");
+    viewport = await promptBugText("Viewport", viewport, { placeholder: "1440x900" });
+    profile = await promptBugText("Rig Browser profile", initial.profile || (title ? defaultBrowserBugProfile(title) : undefined), { placeholder: "hp-next-login-loading-clean" });
+  } else {
+    clack.log.info("Browser wiring skipped. The task will keep assets and steps, but no browser block or browser validation.");
+  }
+  const outputRoot = initial.createBeadsTask ? initial.outputRoot : await promptBugText("Output directory", initial.outputRoot || "docs/bug-reports");
+  const overwrite = await promptBugConfirm("Overwrite if report exists?", initial.overwrite);
+  clack.outro("Bug report input captured.");
+  return {
+    ...initial,
+    outputRoot,
+    title,
+    url,
+    browserRequired,
+    environment,
+    preset: initial.preset || defaults.preset,
+    profile,
+    attachUrl: initial.attachUrl || defaults.attachUrl,
+    stateDir: initial.stateDir || defaults.stateDir,
+    viewport,
+    summary,
+    steps,
+    expected,
+    actual,
+    evidence,
+    screenshots: initial.screenshots,
+    assets,
+    priority,
+    labels,
+    parent: parent || undefined,
+    overwrite
+  };
+}
+async function promptBugText(message, defaultValue, options = {}) {
+  const result = await clack.text({
+    message,
+    defaultValue: defaultValue?.trim() ? defaultValue : undefined,
+    placeholder: options.placeholder,
+    validate: options.required ? (value) => validateRequiredBugPromptValue(value, message) : undefined
+  });
+  return unwrapClackPrompt(result).trim();
+}
+function validateRequiredBugPromptValue(value, label) {
+  return value?.trim() ? undefined : `${label} is required.`;
+}
+function bugPromptExampleText(section, options = {}) {
+  const c = pc.createColors(options.color ?? shouldColorizeCliOutput());
+  const label = (value) => c.bold(c.cyan(value));
+  const example = (value) => c.green(value);
+  const note2 = (value) => c.dim(value);
+  const rows = {
+    incident: [
+      ["Bug title", "Login page never leaves loading", "short user-visible failure"],
+      ["URL", "https://dev.rig.hptestingsite.com/login?next=%2F", "exact route or endpoint"],
+      ["Summary", "Email field never appears after navigating from credentials", "one sentence"]
+    ],
+    reproduction: [
+      ["Steps", "Open /login; Enter qa@example.com; Press Continue", "semicolon-separated"],
+      ["Expected", "OTP form is visible and accepts a code"],
+      ["Actual", "Loading shell stays forever"]
+    ],
+    evidence: [
+      ["Evidence", "Console: ChunkLoadError for credentials route", "console/network/API notes"],
+      ["Assets", "/Users/me/Desktop/login-loading.png /Users/me/Desktop/otp-flow.webm", "drag files into terminal"]
+    ],
+    routing: [
+      ["Priority", "P1 when login is blocked for all testers"],
+      ["Labels", "auth, otp, hp-next", "comma- or semicolon-separated"],
+      ["Parent", "bd-auth-epic-123", "optional"]
+    ],
+    browser: [
+      ["Browser needed", "Yes for console/network/auth/visual bugs"],
+      ["Browser not needed", "No for API-only/server/config bugs"],
+      ["Profile", "hp-next-login-loading-clean", "clean, bug-specific auth state"],
+      ["Viewport", "1440x900", "match the failing screen size"]
+    ]
+  };
+  return rows[section].map(([name, value, detail]) => {
+    const suffix = detail ? ` ${note2(`(${detail})`)}` : "";
+    return `${label(name)}: ${example(value)}${suffix}`;
+  }).join(`
+`);
+}
+async function promptBugConfirm(message, initialValue) {
+  const result = await clack.confirm({
+    message,
+    initialValue
+  });
+  return unwrapClackPrompt(result);
+}
+async function promptBugSelect(message, options, initialValue) {
+  const result = await clack.select({
+    message,
+    options,
+    initialValue
+  });
+  return unwrapClackPrompt(result);
+}
+function unwrapClackPrompt(result) {
+  if (clack.isCancel(result)) {
+    clack.cancel("Bug report cancelled.");
+    throw new CliError2("Bug report cancelled by user.");
+  }
+  return result;
+}
+function normalizeBugEnvironmentChoice(environment) {
+  return environment === "local" || environment === "shared-dev" || environment === "staging" || environment === "production" ? environment : "custom";
+}
+function requireReportBugValue(value, option) {
+  const normalized = value?.trim();
+  if (!normalized) {
+    throw new CliError2(`Missing ${option}. Run interactively or pass ${option} <value>.`);
+  }
+  return normalized;
+}
+function splitPromptList(value) {
+  if (!value) {
+    return [];
+  }
+  return value.split(/[;\n]/).map((item) => item.trim()).filter(Boolean);
+}
+function splitCliAssetOption(value) {
+  return splitDroppedAssetList(value, { splitWhitespace: false });
+}
+function formatDroppedAssetDefault(value) {
+  return value.replace(/([\\\s;"'])/g, "\\$1");
+}
+function splitDroppedAssetList(value, options = {}) {
+  if (!value) {
+    return [];
+  }
+  const splitWhitespace = options.splitWhitespace ?? true;
+  const values = [];
+  let current = "";
+  let quote = null;
+  let escaped = false;
+  const push = () => {
+    const normalized = current.trim();
+    if (normalized) {
+      values.push(normalized);
+    }
+    current = "";
+  };
+  for (const char of value) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) {
+        quote = null;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+    if (char === ";" || char === `
+` || splitWhitespace && /\s/.test(char)) {
+      push();
+      continue;
+    }
+    current += char;
+  }
+  if (escaped) {
+    current += "\\";
+  }
+  push();
+  return values;
+}
+function splitLabelList(value) {
+  if (!value) {
+    return [];
+  }
+  return value.split(/[;,\n]/).map(sanitizeBugReportLabel).filter(Boolean);
+}
+function takeRepeatedOption(args, option) {
+  const rest = [];
+  const values = [];
+  for (let index = 0;index < args.length; index += 1) {
+    const current = args[index];
+    if (current === option) {
+      const next = args[index + 1];
+      if (!next || next.startsWith("-")) {
+        throw new CliError2(`Missing value for ${option}`);
+      }
+      values.push(next);
+      index += 1;
+      continue;
+    }
+    if (current !== undefined) {
+      rest.push(current);
+    }
+  }
+  return { values, rest };
+}
+export {
+  validateRequiredBugPromptValue,
+  splitDroppedAssetList,
+  promptBugText,
+  promptBugConfirm,
+  formatDroppedAssetDefault,
+  executeTaskReportBug,
+  bugPromptExampleText
+};