@bugmole/cli 0.4.0 → 0.6.0

package/src/registry-worker/jira/workflow.ts

@@ -0,0 +1,577 @@
+// The Jira workflow, on top of Bugmole's own pieces:
+//
+// 1. A project manager links a Jira site and project (routes.ts).
+// 2. proposePlan: pending test case proposals become one Jira issue
+//    (label bugmole-plan) summarizing the proposed scope and cases.
+// 3. People approve in Bugmole (proposals + the project's approval mode);
+//    refreshPlanIssue reflects the decisions on that issue.
+// 4. syncTickets: every approved case gets one Jira ticket (label
+//    bugmole-test), found again by a per-case label so it's never duplicated.
+// 5. reportRun: after a run, passed tickets move to Done; failed ones move to
+//    Blocked (or get the bugmole-blocked label) and @mention the assignee and
+//    reporter, with the result and a link to the evidence.
+// 7/8. requestRetest: a comment that mentions Bugmole queues a run scoped to
+//    that ticket's case, which reportRun then reports on the same ticket.
+import type { Env, Principal } from "../core.js";
+import { newId, sha256 } from "../core.js";
+import { runService, type RunCaseScope } from "../hooks.js";
+import { detachedContext } from "../routes/index.js";
+import {
+  adf, blockedTransition, doneTransition, JiraApiError, type AdfNode, type JiraClient, type JiraIssue,
+} from "../../integrations/jira.js";
+import { clientFor, connectionOf, dashboardUrl, issueUrl, type ConnectionRow } from "./connection.js";
+
+export const PLAN_LABEL = "bugmole-plan";
+export const TEST_LABEL = "bugmole-test";
+export const BLOCKED_LABEL = "bugmole-blocked";
+export const RETIRED_LABEL = "bugmole-retired";
+
+/** Thrown when a run's results aren't written yet: the outbox retries later. */
+export class ResultsNotReady extends Error {}
+
+export type CaseContent = {
+  caseSetId: string;
+  caseId: string;
+  revision: number;
+  title: string;
+  intent?: string;
+  steps: string[];
+  expected: string[];
+  journeyId?: string | null;
+};
+
+export type Verdict = { caseSetId: string; caseId: string; status: "passed" | "failed" | "blocked" | "needs_setup"; detail: string };
+
+type LinkRow = {
+  project_id: string;
+  case_set_id: string;
+  case_id: string;
+  case_revision: number;
+  case_title: string | null;
+  journey_id: string | null;
+  jira_issue_key: string | null;
+  jira_issue_id: string | null;
+  last_result: string | null;
+  last_run_id: string | null;
+  updated_at: string;
+};
+
+type ProposalRow = {
+  id: string;
+  caseSetId: string;
+  caseId: string;
+  action: "add" | "change" | "retire";
+  baseRevision: number | null;
+  proposedJson: string | null;
+  summary: string;
+  status: string;
+  appliedRevision: number | null;
+};
+
+function strings(value: unknown): string[] {
+  return Array.isArray(value) ? value.filter((item): item is string => typeof item === "string" && Boolean(item.trim())) : [];
+}
+
+function parse(json: string | null): Record<string, unknown> {
+  try {
+    return json ? JSON.parse(json) as Record<string, unknown> : {};
+  } catch {
+    return {};
+  }
+}
+
+function testsUrl(env: Env, projectId: string): string {
+  return `${dashboardUrl(env)}/plans?${new URLSearchParams({ project: projectId })}`;
+}
+
+function runUrl(env: Env, projectId: string, runId: string): string {
+  return `${dashboardUrl(env)}/runs?${new URLSearchParams({ project: projectId, run: runId })}`;
+}
+
+/** A label only this case's ticket carries, so a lost write never becomes a second ticket. */
+export async function caseLabel(projectId: string, caseSetId: string, caseId: string): Promise<string> {
+  return `bugmole-case-${(await sha256(`${projectId}|${caseSetId}|${caseId}`)).slice(0, 16)}`;
+}
+
+async function managedStorage(env: Env, projectId: string): Promise<boolean> {
+  if (!env.ARTIFACTS) return false;
+  const row = await env.DB.prepare("SELECT storage_mode AS storageMode FROM projects WHERE id = ?").bind(projectId).first<{ storageMode: string }>();
+  return row?.storageMode === "managed";
+}
+
+async function readJson(env: Env, key: string): Promise<any | null> {
+  const object = await env.ARTIFACTS?.get(key);
+  if (!object) return null;
+  try {
+    return JSON.parse(await object.text());
+  } catch {
+    return null;
+  }
+}
+
+async function listKeys(env: Env, prefix: string): Promise<string[]> {
+  if (!env.ARTIFACTS) return [];
+  const keys: string[] = [];
+  let cursor: string | undefined;
+  for (let page = 0; page < 20; page += 1) {
+    const listed = await env.ARTIFACTS.list({ prefix, cursor, limit: 1000 });
+    keys.push(...listed.objects.map((object) => object.key));
+    if (!listed.truncated) break;
+    cursor = (listed as { cursor?: string }).cursor;
+    if (!cursor) break;
+  }
+  return keys;
+}
+
+// --- Step 2/3: the proposed test plan as one Jira issue -------------------------------------
+
+function proposalCase(row: ProposalRow): Partial<CaseContent> {
+  const proposed = parse(row.proposedJson);
+  return {
+    title: typeof proposed.title === "string" ? proposed.title : row.caseId,
+    intent: typeof proposed.intent === "string" ? proposed.intent : undefined,
+    steps: strings(proposed.steps),
+    expected: strings(proposed.expected),
+  };
+}
+
+function planDescription(env: Env, projectId: string, proposals: ProposalRow[]) {
+  const caseSets = [...new Set(proposals.map((row) => row.caseSetId))];
+  const blocks: AdfNode[] = [
+    adf.paragraph(adf.text(`Bugmole proposes ${proposals.length} test case change${proposals.length === 1 ? "" : "s"} across ${caseSets.length} case set${caseSets.length === 1 ? "" : "s"} (${caseSets.join(", ")}).`)),
+    adf.paragraph(adf.text("Review and approve them in Bugmole: "), adf.link("open the proposals", testsUrl(env, projectId)), adf.text(". Once approved, Bugmole creates one ticket per test and reports every run's result on it.")),
+    adf.heading(3, "Proposed scope"),
+    adf.bullets(proposals.map((row) => {
+      const content = proposalCase(row);
+      return [adf.strong(`${row.action === "add" ? "Add" : row.action === "change" ? "Change" : "Retire"}: ${content.title}`), adf.text(` (${row.caseSetId}/${row.caseId}) — ${row.summary}`)];
+    })),
+  ];
+  for (const row of proposals.filter((item) => item.action !== "retire")) {
+    const content = proposalCase(row);
+    blocks.push(adf.heading(4, content.title ?? row.caseId));
+    if (content.intent) blocks.push(adf.paragraph(adf.text(content.intent)));
+    if (content.steps?.length) blocks.push(adf.paragraph(adf.strong("Steps")), adf.ordered(content.steps));
+    if (content.expected?.length) blocks.push(adf.paragraph(adf.strong("Expected")), adf.bullets(content.expected.map((item) => [adf.text(item)])));
+  }
+  return adf.doc(...blocks);
+}
+
+export type PlanIssueResult = { status: 200 | 201; planIssue: { id: string; key: string; url: string; proposalIds: string[]; status: string } };
+
+export async function proposePlan(env: Env, principal: Principal, row: ConnectionRow): Promise<PlanIssueResult | { error: string; status: 422 }> {
+  const projectId = row.project_id;
+  const pending = await env.DB.prepare(`
+    SELECT id, case_set_id AS caseSetId, case_id AS caseId, action, base_revision AS baseRevision, proposed_json AS proposedJson,
+           summary, status, applied_revision AS appliedRevision
+    FROM spec_proposals WHERE project_id = ? AND kind = 'test_case' AND status = 'pending'
+    ORDER BY created_at ASC LIMIT 100
+  `).bind(projectId).all<ProposalRow>();
+  if (!pending.results.length) return { error: "There are no proposed test cases waiting for review.", status: 422 };
+  const proposalIds = pending.results.map((proposal) => proposal.id).sort();
+  const open = await env.DB.prepare("SELECT id, jira_issue_key AS key, proposal_ids_json AS ids, status FROM jira_plan_issues WHERE project_id = ? AND status = 'proposed'")
+    .bind(projectId).all<{ id: string; key: string; ids: string; status: string }>();
+  const same = open.results.find((issue) => JSON.stringify(JSON.parse(issue.ids)) === JSON.stringify(proposalIds));
+  if (same) return { status: 200, planIssue: { id: same.id, key: same.key, url: issueUrl(row, same.key), proposalIds, status: same.status } };
+
+  const client = await clientFor(env, row);
+  const project = await env.DB.prepare("SELECT name FROM projects WHERE id = ?").bind(projectId).first<{ name: string }>();
+  const created = await client.createIssue({
+    project: { key: row.jira_project_key },
+    issuetype: { name: "Task" },
+    summary: `[Bugmole] Proposed test plan for ${project?.name ?? projectId}: ${proposalIds.length} test case${proposalIds.length === 1 ? "" : "s"}`.slice(0, 250),
+    labels: [PLAN_LABEL],
+    description: planDescription(env, projectId, pending.results),
+  });
+  const id = newId("jplan");
+  await env.DB.prepare(`
+    INSERT INTO jira_plan_issues (id, project_id, jira_issue_key, proposal_ids_json, status, created_by) VALUES (?, ?, ?, ?, 'proposed', ?)
+  `).bind(id, projectId, created.key, JSON.stringify(proposalIds), principal.aegisId).run();
+  return { status: 201, planIssue: { id, key: created.key, url: issueUrl(row, created.key), proposalIds, status: "proposed" } };
+}
+
+/** Once every proposal on a plan issue is decided, says so on the issue and moves it to Done. */
+export async function refreshPlanIssue(env: Env, planIssueId: string): Promise<void> {
+  const plan = await env.DB.prepare("SELECT id, project_id AS projectId, jira_issue_key AS key, proposal_ids_json AS ids, status FROM jira_plan_issues WHERE id = ?")
+    .bind(planIssueId).first<{ id: string; projectId: string; key: string; ids: string; status: string }>();
+  if (!plan || plan.status !== "proposed") return;
+  const row = await connectionOf(env, plan.projectId);
+  if (!row?.enabled) return;
+  const ids = JSON.parse(plan.ids) as string[];
+  const placeholders = ids.map(() => "?").join(", ");
+  const proposals = await env.DB.prepare(`SELECT id, status FROM spec_proposals WHERE project_id = ? AND id IN (${placeholders})`)
+    .bind(plan.projectId, ...ids).all<{ id: string; status: string }>();
+  if (proposals.results.some((proposal) => proposal.status === "pending")) return;
+  const accepted = proposals.results.filter((proposal) => proposal.status === "accepted").length;
+  const status = accepted === 0 ? "rejected" : accepted === ids.length ? "approved" : "partially_approved";
+  // Claim the change first, so a repeated delivery doesn't comment twice.
+  const claimed = await env.DB.prepare("UPDATE jira_plan_issues SET status = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ? AND status = 'proposed'")
+    .bind(status, plan.id).run();
+  if ((claimed.meta?.changes ?? 0) !== 1) return;
+  try {
+    const client = await clientFor(env, row);
+    const words = status === "approved" ? "The test plan was approved in Bugmole" : status === "rejected" ? "The test plan was rejected in Bugmole" : "The test plan was partly approved in Bugmole";
+    await client.comment(plan.key, adf.doc(adf.paragraph(
+      adf.text(`${words}: ${accepted} of ${ids.length} proposed test case change${ids.length === 1 ? "" : "s"} accepted. `),
+      ...(accepted ? [adf.text("Bugmole creates a ticket (label bugmole-test) for each approved test.")] : []),
+    )));
+    const transition = doneTransition(await client.transitions(plan.key));
+    if (transition) await client.transition(plan.key, transition.id);
+  } catch (error) {
+    await env.DB.prepare("UPDATE jira_plan_issues SET status = 'proposed' WHERE id = ?").bind(plan.id).run();
+    throw error;
+  }
+}
+
+// --- Step 4: one ticket per approved test case ---------------------------------------------
+
+/** Approved cases: accepted proposals, plus (on request, Bugmole storage only) every active case already in the spec. */
+export async function approvedCases(env: Env, projectId: string, includeExisting: boolean): Promise<{ cases: CaseContent[]; retired: Array<{ caseSetId: string; caseId: string }> }> {
+  const byCase = new Map<string, CaseContent>();
+  const retired = new Map<string, { caseSetId: string; caseId: string }>();
+  const caseSets = new Map<string, any>();
+  const managed = await managedStorage(env, projectId);
+  const caseSetOf = async (caseSetId: string) => {
+    if (!managed) return null;
+    if (!caseSets.has(caseSetId)) caseSets.set(caseSetId, await readJson(env, `projects/${projectId}/test-cases/${caseSetId}.json`));
+    return caseSets.get(caseSetId);
+  };
+  if (includeExisting && managed) {
+    for (const key of await listKeys(env, `projects/${projectId}/test-cases/`)) {
+      if (!key.endsWith(".json")) continue;
+      const caseSet = await readJson(env, key);
+      if (!caseSet || typeof caseSet.caseSetId !== "string" || !Array.isArray(caseSet.cases)) continue;
+      caseSets.set(caseSet.caseSetId, caseSet);
+      for (const item of caseSet.cases) {
+        if (typeof item?.caseId !== "string" || item.status === "obsolete") continue;
+        byCase.set(`${caseSet.caseSetId}/${item.caseId}`, {
+          caseSetId: caseSet.caseSetId,
+          caseId: item.caseId,
+          revision: Number.isInteger(item.revision) && item.revision > 0 ? item.revision : 1,
+          title: typeof item.title === "string" ? item.title : item.caseId,
+          intent: typeof item.intent === "string" ? item.intent : undefined,
+          steps: strings(item.steps),
+          expected: strings(item.expected),
+          journeyId: typeof caseSet.journeyId === "string" ? caseSet.journeyId : null,
+        });
+      }
+    }
+  }
+  const accepted = await env.DB.prepare(`
+    SELECT id, case_set_id AS caseSetId, case_id AS caseId, action, base_revision AS baseRevision, proposed_json AS proposedJson,
+           summary, status, applied_revision AS appliedRevision
+    FROM spec_proposals WHERE project_id = ? AND kind = 'test_case' AND status = 'accepted'
+    ORDER BY created_at ASC
+  `).bind(projectId).all<ProposalRow>();
+  for (const proposal of accepted.results) {
+    const key = `${proposal.caseSetId}/${proposal.caseId}`;
+    if (proposal.action === "retire") {
+      byCase.delete(key);
+      retired.set(key, { caseSetId: proposal.caseSetId, caseId: proposal.caseId });
+      continue;
+    }
+    retired.delete(key);
+    const content = proposalCase(proposal);
+    const caseSet = await caseSetOf(proposal.caseSetId);
+    byCase.set(key, {
+      caseSetId: proposal.caseSetId,
+      caseId: proposal.caseId,
+      revision: proposal.appliedRevision ?? (proposal.action === "add" ? 1 : (proposal.baseRevision ?? 0) + 1),
+      title: content.title ?? proposal.caseId,
+      intent: content.intent,
+      steps: content.steps ?? [],
+      expected: content.expected ?? [],
+      journeyId: typeof caseSet?.journeyId === "string" ? caseSet.journeyId : null,
+    });
+  }
+  return { cases: [...byCase.values()], retired: [...retired.values()] };
+}
+
+function ticketDescription(env: Env, projectId: string, content: CaseContent) {
+  const blocks: AdfNode[] = [];
+  if (content.intent) blocks.push(adf.paragraph(adf.text(content.intent)));
+  if (content.steps.length) blocks.push(adf.heading(3, "Steps"), adf.ordered(content.steps));
+  if (content.expected.length) blocks.push(adf.heading(3, "Expected"), adf.bullets(content.expected.map((item) => [adf.text(item)])));
+  blocks.push(adf.paragraph(
+    adf.text(`Bugmole test case ${content.caseSetId}/${content.caseId}, revision ${content.revision}. `),
+    adf.link("Open in Bugmole", testsUrl(env, projectId)),
+  ));
+  blocks.push(adf.paragraph(adf.text("Bugmole moves this ticket to Done when the test passes and to Blocked when it fails. After a fix, mention Bugmole in a comment and it retests just this case.")));
+  return adf.doc(...blocks);
+}
+
+function ticketSummary(content: CaseContent): string {
+  return `[Bugmole] ${content.title}`.slice(0, 250);
+}
+
+export type SyncResult = { created: string[]; updated: string[]; linked: string[]; retired: string[] };
+
+export async function syncTickets(env: Env, projectId: string, options: { includeExisting?: boolean } = {}): Promise<SyncResult> {
+  const result: SyncResult = { created: [], updated: [], linked: [], retired: [] };
+  const row = await connectionOf(env, projectId);
+  if (!row?.enabled) return result;
+  const { cases, retired } = await approvedCases(env, projectId, Boolean(options.includeExisting));
+  if (!cases.length && !retired.length) return result;
+  const client = await clientFor(env, row);
+  for (const content of cases) {
+    await env.DB.prepare(`
+      INSERT INTO jira_issue_links (project_id, case_set_id, case_id, case_revision, case_title, journey_id) VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(project_id, case_set_id, case_id) DO NOTHING
+    `).bind(projectId, content.caseSetId, content.caseId, content.revision, content.title, content.journeyId ?? null).run();
+    const link = (await env.DB.prepare("SELECT * FROM jira_issue_links WHERE project_id = ? AND case_set_id = ? AND case_id = ?")
+      .bind(projectId, content.caseSetId, content.caseId).first<LinkRow>())!;
+    if (link.jira_issue_key) {
+      if (link.case_revision !== content.revision) {
+        await client.editIssue(link.jira_issue_key, { fields: { summary: ticketSummary(content), description: ticketDescription(env, projectId, content) } });
+        await env.DB.prepare(`
+          UPDATE jira_issue_links SET case_revision = ?, case_title = ?, journey_id = COALESCE(?, journey_id), updated_at = CURRENT_TIMESTAMP
+          WHERE project_id = ? AND case_set_id = ? AND case_id = ?
+        `).bind(content.revision, content.title, content.journeyId ?? null, projectId, content.caseSetId, content.caseId).run();
+        result.updated.push(link.jira_issue_key);
+      }
+      continue;
+    }
+    // Claim the case, so two syncs at once don't both create a ticket. A
+    // claim older than five minutes is from a sync that died mid-way.
+    const token = `creating:${newId("c")}`;
+    const claimed = await env.DB.prepare(`
+      UPDATE jira_issue_links SET jira_issue_id = ?, updated_at = CURRENT_TIMESTAMP
+      WHERE project_id = ? AND case_set_id = ? AND case_id = ? AND jira_issue_key IS NULL
+        AND (jira_issue_id IS NULL OR updated_at < datetime('now', '-5 minutes'))
+    `).bind(token, projectId, content.caseSetId, content.caseId).run();
+    if ((claimed.meta?.changes ?? 0) !== 1) continue;
+    try {
+      const label = await caseLabel(projectId, content.caseSetId, content.caseId);
+      const [found] = await client.search(`project = "${row.jira_project_key}" AND labels = "${TEST_LABEL}" AND labels = "${label}" ORDER BY created ASC`);
+      const issue = found ?? await client.createIssue({
+        project: { key: row.jira_project_key },
+        issuetype: { name: "Task" },
+        summary: ticketSummary(content),
+        labels: [TEST_LABEL, label],
+        description: ticketDescription(env, projectId, content),
+      });
+      await env.DB.prepare(`
+        UPDATE jira_issue_links SET jira_issue_key = ?, jira_issue_id = ?, case_revision = ?, case_title = ?, journey_id = COALESCE(?, journey_id), updated_at = CURRENT_TIMESTAMP
+        WHERE project_id = ? AND case_set_id = ? AND case_id = ?
+      `).bind(issue.key, issue.id, content.revision, content.title, content.journeyId ?? null, projectId, content.caseSetId, content.caseId).run();
+      (found ? result.linked : result.created).push(issue.key);
+    } catch (error) {
+      await env.DB.prepare("UPDATE jira_issue_links SET jira_issue_id = NULL WHERE project_id = ? AND case_set_id = ? AND case_id = ? AND jira_issue_id = ?")
+        .bind(projectId, content.caseSetId, content.caseId, token).run();
+      throw error;
+    }
+  }
+  for (const item of retired) {
+    const link = await env.DB.prepare("SELECT * FROM jira_issue_links WHERE project_id = ? AND case_set_id = ? AND case_id = ?")
+      .bind(projectId, item.caseSetId, item.caseId).first<LinkRow>();
+    if (!link?.jira_issue_key || link.last_result === "retired") continue;
+    await client.labels(link.jira_issue_key, { add: [RETIRED_LABEL] });
+    await client.comment(link.jira_issue_key, adf.doc(adf.paragraph(adf.text("Bugmole: this test case was retired in Bugmole, so it no longer runs and this ticket gets no more results."))));
+    await env.DB.prepare("UPDATE jira_issue_links SET last_result = 'retired', updated_at = CURRENT_TIMESTAMP WHERE project_id = ? AND case_set_id = ? AND case_id = ?")
+      .bind(projectId, item.caseSetId, item.caseId).run();
+    result.retired.push(link.jira_issue_key);
+  }
+  return result;
+}
+
+// --- Step 5/8: results back onto tickets ---------------------------------------------------
+
+type RunRow = {
+  id: string;
+  projectId: string;
+  status: string;
+  completedAt: string | null;
+  caseScopeJson: string | null;
+  errorMessage: string | null;
+  stepsFailed: number | null;
+};
+
+const TERMINAL = new Set(["success", "partial", "error", "cancelled"]);
+const VERDICTS = new Set(["passed", "failed", "blocked", "needs_setup"]);
+
+function resultsOf(record: any, runId: string): Verdict[] {
+  if (!record || record.runId !== runId || typeof record.caseSetId !== "string" || !Array.isArray(record.results)) return [];
+  return record.results
+    .filter((item: any) => typeof item?.caseId === "string" && VERDICTS.has(item.status))
+    .map((item: any) => ({ caseSetId: record.caseSetId, caseId: item.caseId, status: item.status, detail: typeof item.detail === "string" ? item.detail : "" }));
+}
+
+function minutesSince(timestamp: string | null): number {
+  if (!timestamp) return Number.POSITIVE_INFINITY;
+  const parsed = Date.parse(timestamp.includes("T") ? timestamp : `${timestamp.replace(" ", "T")}Z`);
+  return Number.isFinite(parsed) ? (Date.now() - parsed) / 60_000 : Number.POSITIVE_INFINITY;
+}
+
+/**
+ * The case verdicts a run recorded. Runs record them in the project's
+ * storage just after they finish, so an empty answer soon after the run
+ * throws ResultsNotReady and the outbox asks again. A retest of one case
+ * whose verdicts can't be read (a project's own storage) is judged by the
+ * run's own outcome, since that run tested only that case.
+ */
+export async function verdictsForRun(env: Env, run: RunRow, caseSetIds: string[]): Promise<Verdict[]> {
+  const scope = run.caseScopeJson ? parse(run.caseScopeJson) as unknown as RunCaseScope : null;
+  const managed = await managedStorage(env, run.projectId);
+  if (managed) {
+    const found: Verdict[] = [];
+    const wanted = scope ? [scope.caseSetId] : caseSetIds;
+    for (const caseSetId of wanted) {
+      const latest = resultsOf(await readJson(env, `projects/${run.projectId}/test-case-results/${caseSetId}.json`), run.id);
+      if (latest.length) {
+        found.push(...latest);
+        continue;
+      }
+      const history = (await listKeys(env, `projects/${run.projectId}/test-case-history/${caseSetId}/`)).filter((key) => key.endsWith(`-${run.id}.json`));
+      for (const key of history) found.push(...resultsOf(await readJson(env, key), run.id));
+    }
+    const scoped = scope ? found.filter((verdict) => scope.caseIds.includes(verdict.caseId)) : found;
+    if (scoped.length) return scoped;
+    if (minutesSince(run.completedAt) < (scope ? 3 : 30)) throw new ResultsNotReady(`No case verdicts for run ${run.id} yet`);
+  }
+  if (!scope || run.status === "cancelled") return [];
+  const status = run.status === "success" ? "passed" : "failed";
+  const detail = status === "passed" ? "The retest run passed." : run.errorMessage?.trim() || `The retest run ended ${run.status}${run.stepsFailed ? ` with ${run.stepsFailed} failed step(s)` : ""}.`;
+  return scope.caseIds.map((caseId) => ({ caseSetId: scope.caseSetId, caseId, status, detail }));
+}
+
+function mentionsFor(issue: JiraIssue, row: ConnectionRow): AdfNode[] {
+  const people = new Map<string, string | undefined>();
+  for (const person of [issue.fields.assignee, issue.fields.reporter]) {
+    if (person?.accountId && person.accountId !== row.account_id) people.set(person.accountId, person.displayName);
+  }
+  return [...people].flatMap(([accountId, name]) => [adf.mention(accountId, name), adf.text(" ")]);
+}
+
+/** Moves one ticket for one verdict and comments with the result. */
+export async function applyVerdict(env: Env, client: JiraClient, row: ConnectionRow, issueKey: string, verdict: Verdict, run: { id: string; projectId: string }, revision: number): Promise<"done" | "blocked" | "labelled" | "commented"> {
+  const issue = await client.getIssue(issueKey);
+  const evidence = adf.link("the run and its evidence", runUrl(env, run.projectId, run.id));
+  const detail = verdict.detail ? ` ${verdict.detail}` : "";
+  const labels = issue.fields.labels ?? [];
+  if (verdict.status === "passed") {
+    let outcome: "done" | "commented" = "commented";
+    if (issue.fields.status?.statusCategory?.key !== "done") {
+      const transition = doneTransition(await client.transitions(issueKey));
+      if (transition) {
+        await client.transition(issueKey, transition.id);
+        outcome = "done";
+      }
+    } else {
+      outcome = "done";
+    }
+    if (labels.includes(BLOCKED_LABEL)) await client.labels(issueKey, { remove: [BLOCKED_LABEL] });
+    await client.comment(issueKey, adf.doc(adf.paragraph(
+      adf.strong("Bugmole: passed."),
+      adf.text(`${detail} Revision ${revision} of ${verdict.caseSetId}/${verdict.caseId}. See `),
+      evidence,
+      adf.text("."),
+    )));
+    return outcome;
+  }
+  if (verdict.status === "needs_setup") {
+    await client.comment(issueKey, adf.doc(adf.paragraph(
+      adf.strong("Bugmole: couldn't run this test yet."),
+      adf.text(`${detail} See `),
+      evidence,
+      adf.text("."),
+    )));
+    return "commented";
+  }
+  let outcome: "blocked" | "labelled" = "labelled";
+  const transition = issue.fields.status?.name?.toLowerCase() === "blocked" ? null : blockedTransition(await client.transitions(issueKey));
+  if (issue.fields.status?.name?.toLowerCase() === "blocked") outcome = "blocked";
+  else if (transition) {
+    await client.transition(issueKey, transition.id);
+    outcome = "blocked";
+  }
+  if (outcome === "labelled" && !labels.includes(BLOCKED_LABEL)) await client.labels(issueKey, { add: [BLOCKED_LABEL] });
+  await client.comment(issueKey, adf.doc(adf.paragraph(
+    ...mentionsFor(issue, row),
+    adf.strong(verdict.status === "blocked" ? "Bugmole: blocked." : "Bugmole: failed."),
+    adf.text(`${detail} Revision ${revision} of ${verdict.caseSetId}/${verdict.caseId}. See `),
+    evidence,
+    adf.text(". When it's fixed, mention Bugmole in a comment on this ticket to retest just this case."),
+  )));
+  return outcome;
+}
+
+export type ReportResult = { reported: Array<{ issueKey: string; status: string; outcome: string }> };
+
+export async function reportRun(env: Env, runId: string): Promise<ReportResult> {
+  const result: ReportResult = { reported: [] };
+  const run = await env.DB.prepare(`
+    SELECT id, project_id AS projectId, status, completed_at AS completedAt, case_scope_json AS caseScopeJson,
+           error_message AS errorMessage, steps_failed AS stepsFailed
+    FROM runs WHERE id = ?
+  `).bind(runId).first<RunRow>();
+  if (!run || !TERMINAL.has(run.status)) return result;
+  const row = await connectionOf(env, run.projectId);
+  if (!row?.enabled) return result;
+  const links = await env.DB.prepare("SELECT * FROM jira_issue_links WHERE project_id = ? AND jira_issue_key IS NOT NULL AND COALESCE(last_result, '') <> 'retired'")
+    .bind(run.projectId).all<LinkRow>();
+  if (!links.results.length) return result;
+  const verdicts = await verdictsForRun(env, run, [...new Set(links.results.map((link) => link.case_set_id))]);
+  if (!verdicts.length) return result;
+  const client = await clientFor(env, row);
+  for (const verdict of verdicts) {
+    const link = links.results.find((item) => item.case_set_id === verdict.caseSetId && item.case_id === verdict.caseId);
+    if (!link?.jira_issue_key || link.last_run_id === run.id) continue;
+    const outcome = await applyVerdict(env, client, row, link.jira_issue_key, verdict, run, link.case_revision);
+    await env.DB.prepare(`
+      UPDATE jira_issue_links SET last_result = ?, last_run_id = ?, updated_at = CURRENT_TIMESTAMP
+      WHERE project_id = ? AND case_set_id = ? AND case_id = ?
+    `).bind(verdict.status, run.id, run.projectId, link.case_set_id, link.case_id).run();
+    result.reported.push({ issueKey: link.jira_issue_key, status: verdict.status, outcome });
+  }
+  return result;
+}
+
+// --- Step 7/8: a mention asks for a retest of that ticket's case ---------------------------
+
+export type RetestOutcome =
+  | { queued: true; runId: string; issueKey: string; caseSetId: string; caseId: string }
+  | { queued: false; reason: "not_bugmole_ticket" | "no_plan" | "run_refused"; issueKey: string; message?: string };
+
+async function planFor(env: Env, projectId: string, link: LinkRow): Promise<string | null> {
+  let journeyId = link.journey_id;
+  if (!journeyId && (await managedStorage(env, projectId))) {
+    const caseSet = await readJson(env, `projects/${projectId}/test-cases/${link.case_set_id}.json`);
+    journeyId = typeof caseSet?.journeyId === "string" ? caseSet.journeyId : null;
+    if (journeyId) {
+      await env.DB.prepare("UPDATE jira_issue_links SET journey_id = ? WHERE project_id = ? AND case_set_id = ? AND case_id = ?")
+        .bind(journeyId, projectId, link.case_set_id, link.case_id).run();
+    }
+  }
+  if (!journeyId) return null;
+  const plan = await env.DB.prepare("SELECT plan_id AS planId FROM plan_drafts WHERE project_id = ? AND journey_id = ? ORDER BY plan_id LIMIT 1")
+    .bind(projectId, journeyId).first<{ planId: string }>();
+  return plan?.planId ?? null;
+}
+
+export async function requestRetest(env: Env, row: ConnectionRow, issueKey: string, commentId: string): Promise<RetestOutcome> {
+  const link = await env.DB.prepare("SELECT * FROM jira_issue_links WHERE project_id = ? AND jira_issue_key = ?")
+    .bind(row.project_id, issueKey).first<LinkRow>();
+  if (!link) return { queued: false, reason: "not_bugmole_ticket", issueKey };
+  const planId = await planFor(env, row.project_id, link);
+  if (!planId) return { queued: false, reason: "no_plan", issueKey };
+  if (!runService.create) throw new Error("Run creation isn't wired");
+  // Runs as the person who connected Jira, through the same checks as the API.
+  const principal: Principal = { aegisId: row.created_by, projectIds: [], scopes: ["*"] };
+  const request = new Request("https://registry.internal/jira", {
+    method: "POST",
+    body: JSON.stringify({
+      planId,
+      idempotencyKey: `jira:${row.id}:${issueKey}:${commentId}`,
+      executionMode: row.execution_mode,
+      ...(row.environment_id ? { environmentId: row.environment_id } : {}),
+    }),
+  });
+  const caseScope: RunCaseScope = { caseSetId: link.case_set_id, caseIds: [link.case_id], jiraIssueKey: issueKey };
+  const created = await runService.create(request, env, principal, row.project_id, detachedContext(), { triggerSource: "jira", caseScope });
+  const body = await created.json().catch(() => ({})) as { run?: { id: string }; error?: string };
+  if (!created.ok || !body.run) return { queued: false, reason: "run_refused", issueKey, message: body.error ?? `status ${created.status}` };
+  return { queued: true, runId: body.run.id, issueKey, caseSetId: link.case_set_id, caseId: link.case_id };
+}
+
+export function isPermanentJiraError(error: unknown): boolean {
+  return error instanceof JiraApiError && [400, 401, 403, 404].includes(error.status);
+}

package/src/registry-worker/jobs/retention.ts

@@ -1,6 +1,7 @@
 // Deletes run history older than each workspace's plan allows, including the
 // evidence Bugmole stores for it. Runs in small batches every day.
 import type { Env } from "../core.js";
+import { entitlementMode, historyCutoff } from "../billing/enforcement.js";
 import { getEntitlements } from "../billing/entitlements.js";
 import { recordAudit } from "../org/audit.js";
 import { registerJob } from "./index.js";
@@ -10,9 +11,7 @@ const MAX_RUNS_PER_TICK = 500;
 /** No plan keeps less history than this, so younger runs are never examined. */
 const MIN_HISTORY_DAYS = 7;
 
-export function historyCutoff(historyDays: number | null, now: Date): string | null {
-  return historyDays === null ? null : new Date(now.getTime() - historyDays * 86_400_000).toISOString();
-}
+export { historyCutoff };
 
 async function deletePrefix(bucket: R2Bucket, prefix: string): Promise<number> {
   let cursor: string | undefined;
@@ -29,7 +28,11 @@ async function deletePrefix(bucket: R2Bucket, prefix: string): Promise<number> {
   return deleted;
 }
 
-export async function enforceRetention(env: Env, now = new Date()): Promise<{ runs: number; objects: number }> {
+/**
+ * Deletion follows the "entitlements" rollout like every other plan limit:
+ * enforced, it deletes; in shadow or off, it only logs what it would delete.
+ */
+export async function enforceRetention(env: Env, now = new Date()): Promise<{ runs: number; objects: number; wouldDelete: number }> {
   const oldest = new Date(now.getTime() - MIN_HISTORY_DAYS * 86_400_000).toISOString();
   const workspaces = await env.DB.prepare(`
     SELECT DISTINCT workspace_id AS workspaceId FROM runs
@@ -37,11 +40,24 @@ export async function enforceRetention(env: Env, now = new Date()): Promise<{ ru
   `).bind(oldest).all<{ workspaceId: string }>();
   let runs = 0;
   let objects = 0;
+  let wouldDelete = 0;
   for (const { workspaceId } of workspaces.results) {
     if (runs >= MAX_RUNS_PER_TICK) break;
     const { historyDays } = await getEntitlements(env, workspaceId);
     const cutoff = historyCutoff(historyDays, now);
     if (!cutoff) continue;
+    const mode = await entitlementMode(env, workspaceId);
+    if (mode !== "enforce") {
+      const count = await env.DB.prepare(`
+        SELECT COUNT(*) AS count FROM runs
+        WHERE workspace_id = ? AND status IN ${TERMINAL} AND COALESCE(completed_at, requested_at) < ?
+      `).bind(workspaceId, cutoff).first<{ count: number }>();
+      if (count?.count) {
+        wouldDelete += count.count;
+        console.warn(`[entitlements] ${mode}: retention would delete ${count.count} run(s) older than ${historyDays} days for ${workspaceId}`);
+      }
+      continue;
+    }
     const expired = await env.DB.prepare(`
       SELECT id, project_id AS projectId FROM runs
       WHERE workspace_id = ? AND status IN ${TERMINAL} AND COALESCE(completed_at, requested_at) < ?
@@ -60,7 +76,7 @@ export async function enforceRetention(env: Env, now = new Date()): Promise<{ ru
       workspaceId, action: "runs.expired", data: { count: expired.results.length, historyDays, cutoff },
     });
   }
-  return { runs, objects };
+  return { runs, objects, wouldDelete };
 }
 
 registerJob("daily", "retention", async (env, _ctx, now) => {

package/src/registry-worker/mcp/tools.ts

@@ -193,7 +193,8 @@ export const TOOLS: ToolDefinition[] = [
         workspace: project.workspaceName,
         storage: project.storageMode === "managed" ? "Bugmole" : "your own",
         runsGoTo: project.defaultExecutionMode === "cloud" ? "Bugmole Cloud" : "your workers",
-        readOnly: Boolean(project.lockedAt),
+        readOnly: Boolean(project.lockedAt || project.inactiveAt),
+        paused: Boolean(project.inactiveAt),
         environments: (project.environments ?? []).map((environment: Record<string, any>) => ({
           id: environment.id,
           name: environment.name,