@bugmole/cli 0.4.0

package/src/registry/migrations/0031_gitlab_and_teams.sql

@@ -0,0 +1,45 @@
+-- GitLab merge request checks: each binding brings its own access token and
+-- webhook secret, since there is no Valkyrie-operated GitLab App to install.
+CREATE TABLE IF NOT EXISTS project_gitlab_bindings (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  gitlab_host TEXT NOT NULL DEFAULT 'gitlab.com',
+  gitlab_project_id INTEGER NOT NULL,
+  gitlab_project_path TEXT NOT NULL,
+  access_token_ciphertext TEXT NOT NULL,
+  access_token_iv TEXT NOT NULL,
+  webhook_secret_ciphertext TEXT NOT NULL,
+  webhook_secret_iv TEXT NOT NULL,
+  -- JSON array of plan ids; null runs every published plan.
+  plan_ids_json TEXT,
+  environment_id TEXT,
+  -- merge_request: every open/reopen/update on a merge request.
+  trigger TEXT NOT NULL DEFAULT 'merge_request',
+  -- e.g. https://pr-{number}.preview.example.com; null uses the environment's own URL.
+  base_url_template TEXT,
+  execution_mode TEXT NOT NULL DEFAULT 'cloud',
+  enabled INTEGER NOT NULL DEFAULT 1,
+  created_by TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  UNIQUE (project_id, gitlab_host, gitlab_project_id, trigger)
+);
+CREATE INDEX IF NOT EXISTS project_gitlab_bindings_lookup ON project_gitlab_bindings(gitlab_host, gitlab_project_id);
+
+ALTER TABLE runs ADD COLUMN gitlab_binding_id TEXT;
+CREATE INDEX IF NOT EXISTS runs_gitlab_binding ON runs(gitlab_binding_id);
+
+-- Microsoft Teams alerts: a channel webhook URL from the Workflows app (the
+-- successor to the retired Office 365 Connectors), the same as email or
+-- Slack in alert_rules.channel.
+CREATE TABLE IF NOT EXISTS teams_installations (
+  id TEXT PRIMARY KEY,
+  workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+  name TEXT,
+  webhook_url_ciphertext TEXT NOT NULL,
+  webhook_url_iv TEXT NOT NULL,
+  installed_by TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  revoked_at TEXT,
+  revoked_reason TEXT
+);
+CREATE INDEX IF NOT EXISTS teams_installations_workspace ON teams_installations(workspace_id);

package/src/registry/migrations/0032_personas.sql

@@ -0,0 +1,15 @@
+-- Explore-with-AI journeys are written from a persona's point of view. The
+-- built-in "Curious" persona is lazily created the first time a project's
+-- personas are listed, rather than backfilled here, so every project (old
+-- and new) gets it without a data migration.
+CREATE TABLE IF NOT EXISTS project_personas (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  description TEXT NOT NULL,
+  is_default INTEGER NOT NULL DEFAULT 0,
+  created_by TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  UNIQUE (project_id, name)
+);
+CREATE INDEX IF NOT EXISTS project_personas_project ON project_personas(project_id);

package/src/registry/migrations/0033_bugmole_rename.sql

@@ -0,0 +1,11 @@
+-- Valkyrie is now Bugmole. Stored names that carried the old brand move to
+-- the new one; the registry still accepts "valkyrie" from 0.3.x CLIs and
+-- rewrites it on the way in (currentStorageProvider, parseCloudDevice).
+UPDATE projects SET storage_provider = 'bugmole' WHERE storage_provider = 'valkyrie';
+UPDATE device_authorizations SET storage_provider = 'bugmole' WHERE storage_provider = 'valkyrie';
+UPDATE runs SET targets_json = REPLACE(targets_json, '"provider":"valkyrie"', '"provider":"bugmole"')
+  WHERE targets_json LIKE '%"provider":"valkyrie"%';
+
+DROP INDEX IF EXISTS valkyrie_device_sessions_open;
+ALTER TABLE valkyrie_device_sessions RENAME TO bugmole_device_sessions;
+CREATE INDEX IF NOT EXISTS bugmole_device_sessions_open ON bugmole_device_sessions(status, created_at);

package/src/registry/task-scheduling.test.ts

@@ -0,0 +1,100 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  MAX_TASK_ATTEMPTS,
+  backoffUntil,
+  isClaimableTask,
+  isResumableTask,
+  resumedTaskFields,
+} from "./task-scheduling.js";
+
+const NOW = Date.UTC(2026, 0, 1, 12, 0, 0);
+
+test("a queued task with no history is claimable", () => {
+  assert.equal(isClaimableTask({ status: "queued" }, NOW), true);
+});
+
+test("a blocked task is retried — that is what makes progress possible after a transient failure", () => {
+  assert.equal(isClaimableTask({ status: "blocked", attempts: 1 }, NOW), true);
+});
+
+test("a task that exhausted its attempts is parked, not re-served forever", () => {
+  assert.equal(isClaimableTask({ status: "blocked", attempts: MAX_TASK_ATTEMPTS }, NOW), false);
+  assert.equal(isClaimableTask({ status: "queued", attempts: MAX_TASK_ATTEMPTS + 1 }, NOW), false);
+});
+
+test("a task inside its backoff window is not claimable yet", () => {
+  const future = new Date(NOW + 60_000).toISOString();
+  assert.equal(isClaimableTask({ status: "blocked", attempts: 1, nextAttemptAt: future }, NOW), false);
+});
+
+test("a task whose backoff has elapsed becomes claimable again", () => {
+  const past = new Date(NOW - 1_000).toISOString();
+  assert.equal(isClaimableTask({ status: "blocked", attempts: 1, nextAttemptAt: past }, NOW), true);
+});
+
+test("terminal tasks are never claimable, so cancelling really stops the work", () => {
+  for (const status of ["completed", "error", "running"]) {
+    assert.equal(isClaimableTask({ status }, NOW), false, `${status} must not be claimable`);
+  }
+});
+
+test("backoff grows with attempts and is capped so a task never waits indefinitely", () => {
+  const first = Date.parse(backoffUntil(1, NOW)) - NOW;
+  const second = Date.parse(backoffUntil(2, NOW)) - NOW;
+  const huge = Date.parse(backoffUntil(50, NOW)) - NOW;
+  assert.ok(second > first, "later attempts should wait longer");
+  assert.equal(huge, 30 * 60_000, "backoff is capped at 30 minutes");
+});
+
+test("a running task whose lease lapsed is reclaimable, so one crashed worker cannot wedge the queue", () => {
+  const expired = new Date(NOW - 1_000).toISOString();
+  assert.equal(isClaimableTask({ status: "running", leaseExpiresAt: expired }, NOW), true);
+});
+
+test("a running task with a live lease is left alone, so work is never double-run", () => {
+  const live = new Date(NOW + 30_000).toISOString();
+  assert.equal(isClaimableTask({ status: "running", leaseExpiresAt: live }, NOW), false);
+  // No lease recorded at all is treated as in-flight rather than free.
+  assert.equal(isClaimableTask({ status: "running" }, NOW), false);
+});
+
+test("an exhausted running task is not resurrected by a lapsed lease", () => {
+  const expired = new Date(NOW - 1_000).toISOString();
+  assert.equal(
+    isClaimableTask({ status: "running", leaseExpiresAt: expired, attempts: MAX_TASK_ATTEMPTS }, NOW),
+    false,
+  );
+});
+
+test("an exhausted task is resumable — parking it is a pause, not a one-way door", () => {
+  assert.equal(isResumableTask({ status: "blocked", attempts: MAX_TASK_ATTEMPTS }, NOW), true);
+  assert.equal(isResumableTask({ status: "error", attempts: MAX_TASK_ATTEMPTS }, NOW), true);
+});
+
+test("resuming does not stomp a worker that is still holding the task", () => {
+  const live = new Date(NOW + 30_000).toISOString();
+  assert.equal(isResumableTask({ status: "running", leaseExpiresAt: live }, NOW), false);
+  // A lease that already lapsed means the worker is gone, so the human wins.
+  const expired = new Date(NOW - 1_000).toISOString();
+  assert.equal(isResumableTask({ status: "running", leaseExpiresAt: expired }, NOW), true);
+});
+
+test("finished work is never resumed, so resume cannot undo a completed task", () => {
+  assert.equal(isResumableTask({ status: "completed" }, NOW), false);
+});
+
+test("resuming clears exactly what parked the task", () => {
+  const fields = resumedTaskFields();
+  assert.equal(fields.status, "queued");
+  assert.equal(fields.attempts, 0);
+  assert.equal(fields.nextAttemptAt, null);
+  assert.equal(fields.leaseExpiresAt, null);
+  assert.equal(fields.workerId, null);
+});
+
+test("a resumed task is immediately claimable again — the whole point of resuming", () => {
+  const parked = { status: "blocked", attempts: MAX_TASK_ATTEMPTS, nextAttemptAt: backoffUntil(3, NOW) };
+  assert.equal(isClaimableTask(parked, NOW), false);
+  assert.equal(isClaimableTask({ ...parked, ...resumedTaskFields() }, NOW), true);
+});

package/src/registry/task-scheduling.ts

@@ -0,0 +1,80 @@
+/**
+ * Task retry scheduling, shared by every component that decides whether an
+ * agent task should run now.
+ *
+ * This lives in its own dependency-free module on purpose: the rules are
+ * needed by the Cloudflare Worker registry (which cannot import the Node
+ * `ws` dependency that control-plane-client pulls in), the local registry
+ * stub, the serve worker, and the MCP server. Previously each selection
+ * site independently accepted any queued/blocked task, so a permanently
+ * failing task was re-served on every 5s worker poll, forever.
+ */
+
+/** A task that has burned this many attempts is parked instead of re-served. */
+export const MAX_TASK_ATTEMPTS = 3;
+
+/** Backoff before a blocked task becomes claimable again, capped at 30m. */
+export function backoffUntil(attempts: number, now = Date.now()): string {
+  const delayMs = Math.min(30 * 60_000, 30_000 * 2 ** Math.max(0, attempts - 1));
+  return new Date(now + delayMs).toISOString();
+}
+
+export type SchedulableTask = {
+  status: string;
+  attempts?: number;
+  nextAttemptAt?: string | null;
+  leaseExpiresAt?: string | null;
+};
+
+/**
+ * Whether a human may release a parked task back to the queue.
+ *
+ * `isClaimableTask` parks a task for good once it burns MAX_TASK_ATTEMPTS.
+ * That is right for automatic retries — a task failing the same way every
+ * time should not be re-served on every poll. But nothing could ever
+ * un-park it: the update path writes status, lease and backoff, and never
+ * touches attempts. So a task that stopped to *ask for human input* stayed
+ * dead after the human answered, which made "needs your input" a one-way
+ * door rather than a pause.
+ *
+ * Resuming is an explicit human action, so the attempt cap is not the
+ * question here — the only thing it must not do is stomp a worker that is
+ * genuinely still running the task.
+ */
+export function isResumableTask(task: SchedulableTask, now = Date.now()): boolean {
+  if (task.status === "completed") return false;
+  const heldByLiveWorker = task.status === "running"
+    && Boolean(task.leaseExpiresAt)
+    && Date.parse(task.leaseExpiresAt!) > now;
+  return !heldByLiveWorker;
+}
+
+/**
+ * The fields that release a task: a clean slate on the retry budget, no
+ * pending backoff, and no lease left over from the worker that gave up.
+ */
+export function resumedTaskFields(): {
+  status: "queued";
+  attempts: number;
+  nextAttemptAt: null;
+  leaseExpiresAt: null;
+  workerId: null;
+} {
+  return { status: "queued", attempts: 0, nextAttemptAt: null, leaseExpiresAt: null, workerId: null };
+}
+
+/** Whether a task should be picked up right now. */
+export function isClaimableTask(task: SchedulableTask, now = Date.now()): boolean {
+  // A worker that dies mid-task leaves it "running" forever. The registry
+  // already allows reclaiming such a task once its lease lapses, but the
+  // client-side selection never offered it, so one crash could wedge the
+  // queue — and with it the pipeline, which will not queue a next stage
+  // while anything looks in flight.
+  const staleLease = task.status === "running"
+    && Boolean(task.leaseExpiresAt)
+    && Date.parse(task.leaseExpiresAt!) <= now;
+  if (task.status !== "queued" && task.status !== "blocked" && !staleLease) return false;
+  if ((task.attempts ?? 0) >= MAX_TASK_ATTEMPTS) return false;
+  if (task.nextAttemptAt && Date.parse(task.nextAttemptAt) > now) return false;
+  return true;
+}

package/src/registry-worker/ai/platform-model.ts

@@ -0,0 +1,77 @@
+// Bugmole's own model account, used when a project hasn't connected its own
+// key. Anthropic's Messages API or any OpenAI-compatible gateway.
+
+export type PlatformAiEnv = {
+  PLATFORM_AI_PROVIDER?: string;
+  PLATFORM_AI_KEY?: string;
+  PLATFORM_AI_BASE_URL?: string;
+  PLATFORM_AI_MODEL?: string;
+  /** Test seam. */
+  PLATFORM_AI_FETCH?: typeof fetch;
+};
+
+export type PlatformReply = { text: string; model: string; inputTokens: number | null; outputTokens: number | null };
+
+export function platformAiConfigured(env: PlatformAiEnv): boolean {
+  return Boolean(env.PLATFORM_AI_KEY && (env.PLATFORM_AI_PROVIDER ?? "anthropic"));
+}
+
+function trimmed(url: string) {
+  return url.replace(/\/+$/, "");
+}
+
+export async function callPlatformModel(
+  env: PlatformAiEnv,
+  prompt: string,
+  { maxTokens, timeoutMs }: { maxTokens: number; timeoutMs: number },
+): Promise<PlatformReply> {
+  const provider = (env.PLATFORM_AI_PROVIDER ?? "anthropic").toLowerCase();
+  const model = env.PLATFORM_AI_MODEL || "claude-sonnet-5";
+  const doFetch = env.PLATFORM_AI_FETCH ?? fetch;
+  const signal = AbortSignal.timeout(timeoutMs);
+  if (provider === "anthropic") {
+    const base = env.PLATFORM_AI_BASE_URL ? trimmed(env.PLATFORM_AI_BASE_URL) : "https://api.anthropic.com";
+    const url = base.endsWith("/messages") ? base : base.endsWith("/v1") ? `${base}/messages` : `${base}/v1/messages`;
+    const response = await doFetch(url, {
+      method: "POST",
+      signal,
+      headers: { "content-type": "application/json", "x-api-key": env.PLATFORM_AI_KEY!, "anthropic-version": "2023-06-01" },
+      body: JSON.stringify({ model, max_tokens: maxTokens, messages: [{ role: "user", content: prompt }] }),
+    });
+    if (!response.ok) throw new Error(`Model provider returned ${response.status}`);
+    const data = await response.json() as {
+      model?: string;
+      content?: Array<{ type?: string; text?: string }>;
+      usage?: { input_tokens?: number; output_tokens?: number; cache_read_input_tokens?: number };
+    };
+    return {
+      text: (data.content ?? []).map((part) => part.text ?? "").join(""),
+      model: data.model ?? model,
+      inputTokens: data.usage ? (data.usage.input_tokens ?? 0) + (data.usage.cache_read_input_tokens ?? 0) : null,
+      outputTokens: data.usage?.output_tokens ?? null,
+    };
+  }
+  if (provider === "openai") {
+    const base = env.PLATFORM_AI_BASE_URL ? trimmed(env.PLATFORM_AI_BASE_URL) : "https://api.openai.com/v1";
+    const url = base.endsWith("/chat/completions") ? base : `${base}/chat/completions`;
+    const response = await doFetch(url, {
+      method: "POST",
+      signal,
+      headers: { "content-type": "application/json", authorization: `Bearer ${env.PLATFORM_AI_KEY}` },
+      body: JSON.stringify({ model, max_tokens: maxTokens, messages: [{ role: "user", content: prompt }] }),
+    });
+    if (!response.ok) throw new Error(`Model provider returned ${response.status}`);
+    const data = await response.json() as {
+      model?: string;
+      choices?: Array<{ message?: { content?: string } }>;
+      usage?: { prompt_tokens?: number; completion_tokens?: number };
+    };
+    return {
+      text: data.choices?.[0]?.message?.content ?? "",
+      model: data.model ?? model,
+      inputTokens: data.usage?.prompt_tokens ?? null,
+      outputTokens: data.usage?.completion_tokens ?? null,
+    };
+  }
+  throw new Error(`Unsupported platform model provider: ${provider}`);
+}

package/src/registry-worker/ai/routes.test.ts

@@ -0,0 +1,88 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { call, createTestEnv, seedProject } from "../testing/harness.js";
+import type { Env } from "../core.js";
+
+function fakeModel(reply = "{\"title\":\"x\"}") {
+  const calls: Array<{ url: string; body: any }> = [];
+  const doFetch = (async (url: string, init: RequestInit) => {
+    calls.push({ url, body: JSON.parse(String(init.body)) });
+    return Response.json({ model: "claude-sonnet-5", content: [{ type: "text", text: reply }], usage: { input_tokens: 400, output_tokens: 60 } });
+  }) as unknown as typeof fetch;
+  return { calls, doFetch };
+}
+
+const aiEnv = (doFetch: typeof fetch) => ({ PLATFORM_AI_KEY: "k", PLATFORM_AI_FETCH: doFetch }) as Partial<Env>;
+
+test("AI work is charged once per run, target and purpose", async () => {
+  const model = fakeModel();
+  const { env, db } = createTestEnv(aiEnv(model.doFetch));
+  const { owner, projectId, workspaceId } = await seedProject(env);
+  const ask = () => call(env, "POST", "/api/ai/complete", {
+    as: owner,
+    body: { purpose: "analysis", projectId, runId: "run_1", targetId: "chromium", prompt: "why?" },
+  });
+  const first = await ask();
+  assert.equal(first.status, 200);
+  assert.equal(first.json.credits, 1);
+  assert.equal(first.json.text, "{\"title\":\"x\"}");
+  const retry = await ask();
+  assert.equal(retry.json.credits, 0, "a retry isn't charged again");
+  assert.equal(model.calls.length, 2);
+  assert.equal(model.calls[0].url, "https://api.anthropic.com/v1/messages");
+  assert.equal(model.calls[0].body.max_tokens, 600);
+  const row = db.db.prepare("SELECT quantity, meta_json FROM usage_events WHERE workspace_id = ?").get(workspaceId) as { quantity: number; meta_json: string };
+  assert.equal(row.quantity, 1);
+  assert.deepEqual(JSON.parse(row.meta_json), { purpose: "analysis", targetId: "chromium", model: "claude-sonnet-5", inputTokens: 400, outputTokens: 60 });
+});
+
+test("Free can't buy past its credits, and AI repair needs a paid plan", async () => {
+  const model = fakeModel();
+  const { env } = createTestEnv(aiEnv(model.doFetch));
+  const { owner, projectId } = await seedProject(env);
+  const repair = await call(env, "POST", "/api/ai/complete", {
+    as: owner, body: { purpose: "repair", projectId, runId: "r", prompt: "fix" },
+  });
+  assert.equal(repair.status, 402);
+  assert.equal(repair.json.feature, "aiFixes");
+
+  const explore = (id: string) => call(env, "POST", "/api/ai/complete", {
+    as: owner, body: { purpose: "exploration", projectId, requestId: id, prompt: "map" },
+  });
+  assert.equal((await explore("t1")).json.credits, 100);
+  const second = await explore("t2");
+  assert.equal(second.status, 402, "the 100 Free credits are used up");
+  assert.equal(second.json.limit, "ai_credits");
+  assert.equal(model.calls.length, 1, "no model call when the work can't be paid for");
+});
+
+test("a failed model call costs nothing, and an unconfigured platform says so", async () => {
+  const failing = (async () => new Response("overloaded", { status: 529 })) as unknown as typeof fetch;
+  const { env, db } = createTestEnv(aiEnv(failing));
+  const { owner, projectId } = await seedProject(env);
+  const failed = await call(env, "POST", "/api/ai/complete", { as: owner, body: { purpose: "analysis", projectId, runId: "r", prompt: "x" } });
+  assert.equal(failed.status, 502);
+  assert.equal(db.db.prepare("SELECT COUNT(*) AS c FROM usage_events").get()?.c, 0);
+
+  const bare = createTestEnv();
+  const seeded = await seedProject(bare.env);
+  const unavailable = await call(bare.env, "POST", "/api/ai/complete", {
+    as: seeded.owner, body: { purpose: "analysis", projectId: seeded.projectId, runId: "r", prompt: "x" },
+  });
+  assert.equal(unavailable.status, 503);
+  assert.equal(unavailable.json.code, "ai_unavailable");
+});
+
+test("only project members can spend the project's credits", async () => {
+  const model = fakeModel();
+  const { env } = createTestEnv(aiEnv(model.doFetch));
+  const { projectId } = await seedProject(env);
+  const denied = await call(env, "POST", "/api/ai/complete", {
+    as: "user_stranger", body: { purpose: "analysis", projectId, runId: "r", prompt: "x" },
+  });
+  assert.equal(denied.status, 403);
+  const noKey = await call(env, "POST", "/api/ai/complete", {
+    as: "user_stranger", body: { purpose: "analysis", projectId, prompt: "x" },
+  });
+  assert.equal(noKey.status, 422);
+});

package/src/registry-worker/ai/routes.ts

@@ -0,0 +1,90 @@
+// POST /api/ai/complete — AI work on Bugmole's model account, charged in
+// credits per action (analysis 1, repair 20, exploration 100). Projects that
+// connect their own key call their provider directly and never come here.
+import { AI_CREDIT_COST, type AiAction } from "../../billing/plan-catalog.js";
+import { type Env, type Principal, memberOfProject, requestJson, response } from "../core.js";
+import { getEntitlements, workspaceOfProject } from "../billing/entitlements.js";
+import { canSpend, recordUsage } from "../billing/ledger.js";
+import { checkUsageThresholds } from "../billing/thresholds.js";
+import { type AuthedRouteContext, registerRoutes } from "../routes/index.js";
+import { callPlatformModel, platformAiConfigured, type PlatformAiEnv } from "./platform-model.js";
+
+const MAX_PROMPT_CHARS = 120_000;
+const MAX_OUTPUT_TOKENS: Record<AiAction, number> = { analysis: 600, repair: 2_000, exploration: 8_000, discovery: 0 };
+const TIMEOUT_MS: Record<AiAction, number> = { analysis: 30_000, repair: 60_000, exploration: 120_000, discovery: 0 };
+const PURPOSES = new Set<AiAction>(["analysis", "repair", "exploration"]);
+
+/** `runId` or `requestId` names the work being charged (a discovery task passes its id as the request). */
+export type AiPrincipalCheck = (env: Env, principal: Principal, projectId: string, work: { runId: string | null; requestId: string | null }) => Promise<boolean>;
+
+/** Replaced by the cloud-runner module so run tokens can call this route too. */
+export const aiAccess: { check: AiPrincipalCheck } = {
+  check: (env, principal, projectId) => memberOfProject(env, principal, projectId, "project.write"),
+};
+
+async function complete({ env, principal, request, ctx }: AuthedRouteContext): Promise<Response> {
+  const body = await requestJson(request);
+  const purpose = body?.purpose as AiAction;
+  const projectId = typeof body?.projectId === "string" ? body.projectId : "";
+  const runId = typeof body?.runId === "string" && body.runId ? body.runId : null;
+  const requestId = typeof body?.requestId === "string" && body.requestId ? body.requestId : null;
+  const targetId = typeof body?.targetId === "string" && body.targetId ? body.targetId : "-";
+  const prompt = typeof body?.prompt === "string" ? body.prompt : "";
+  if (!PURPOSES.has(purpose)) return response({ error: "purpose must be analysis, repair, or exploration" }, 422);
+  if (!projectId || !prompt) return response({ error: "projectId and prompt are required" }, 422);
+  if (!runId && !requestId) return response({ error: "runId or requestId is required so the work is charged once" }, 422);
+  if (prompt.length > MAX_PROMPT_CHARS) return response({ error: "prompt is too long" }, 413);
+  if (!(await aiAccess.check(env, principal, projectId, { runId, requestId }))) return response({ error: "Project scope is not allowed" }, 403);
+  const aiEnv = env as Env & PlatformAiEnv;
+  if (!platformAiConfigured(aiEnv)) {
+    return response({ error: "Bugmole AI isn't configured. Connect your own model key in bugmole.config.yaml.", code: "ai_unavailable" }, 503);
+  }
+  const workspaceId = await workspaceOfProject(env, projectId);
+  if (!workspaceId) return response({ error: "This project isn't in a workspace" }, 422);
+  const entitlements = await getEntitlements(env, workspaceId);
+  if (purpose === "repair" && !entitlements.features.aiFixes) {
+    return response({ error: "AI test repair is available on Team and Business plans.", code: "plan_feature", feature: "aiFixes", upgradeUrl: "/billing" }, 402);
+  }
+
+  const credits = AI_CREDIT_COST[purpose];
+  const idempotencyKey = `ai:${projectId}:${runId ?? `req:${requestId}`}:${targetId}:${purpose}`;
+  const alreadyCharged = await env.DB.prepare("SELECT 1 AS charged FROM usage_events WHERE idempotency_key = ?")
+    .bind(idempotencyKey).first<{ charged: number }>();
+  if (!alreadyCharged) {
+    const decision = await canSpend(env, workspaceId, "ai_credit", credits);
+    if (!decision.allowed) {
+      return response({ error: decision.message, code: "plan_limit", limit: decision.reason === "spending_limit" ? "spending_limit" : "ai_credits", upgradeUrl: "/billing" }, 402);
+    }
+  }
+
+  let reply;
+  try {
+    reply = await callPlatformModel(aiEnv, prompt, { maxTokens: MAX_OUTPUT_TOKENS[purpose], timeoutMs: TIMEOUT_MS[purpose] });
+  } catch (error) {
+    // Nothing is charged when the model call fails.
+    console.error("[ai] platform model failed", error);
+    return response({ error: "The AI service didn't respond. Try again shortly.", code: "ai_failed" }, 502);
+  }
+  const charged = await recordUsage(env, {
+    workspaceId,
+    projectId,
+    runId,
+    kind: "ai_credit",
+    quantity: credits,
+    source: "ai",
+    idempotencyKey,
+    meta: { purpose, targetId, model: reply.model, inputTokens: reply.inputTokens, outputTokens: reply.outputTokens },
+  });
+  if (charged) ctx.waitUntil(checkUsageThresholds(env, workspaceId));
+  return response({
+    text: reply.text,
+    model: reply.model,
+    usage: { inputTokens: reply.inputTokens, outputTokens: reply.outputTokens },
+    credits: charged ? credits : 0,
+  });
+}
+
+registerRoutes(async (context) => {
+  if (context.request.method === "POST" && context.url.pathname === "/api/ai/complete") return complete(context);
+  return null;
+});

package/src/registry-worker/artifacts.test.ts

@@ -0,0 +1,98 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  ARTIFACT_STORAGE_UNCONFIGURED,
+  type ArtifactBucket,
+  getProjectArtifact,
+  isProjectArtifactKey,
+  isRunManifestKey,
+  listProjectArtifacts,
+  normalizeArtifactPrefix,
+} from "./artifacts.js";
+
+function fakeBucket(objects: Record<string, { body: string; contentType?: string }>, pageSize = 1000): ArtifactBucket {
+  const keys = Object.keys(objects).sort();
+  return {
+    async list({ prefix, cursor, limit }) {
+      const matching = keys.filter((key) => key.startsWith(prefix));
+      const start = cursor ? Number(cursor) : 0;
+      const size = Math.min(limit ?? pageSize, pageSize);
+      const page = matching.slice(start, start + size);
+      const truncated = start + size < matching.length;
+      return {
+        objects: page.map((key) => ({
+          key,
+          size: objects[key].body.length,
+          uploaded: new Date("2026-09-15T00:00:00Z"),
+          httpMetadata: { contentType: objects[key].contentType },
+        })),
+        truncated,
+        cursor: truncated ? String(start + size) : undefined,
+      };
+    },
+    async get(key) {
+      const object = objects[key];
+      if (!object) return null;
+      return { body: new Response(object.body).body!, size: object.body.length, httpMetadata: { contentType: object.contentType } };
+    },
+  };
+}
+
+const url = (path: string) => new URL(`https://registry.test${path}`);
+
+type ListBody = { objects: Array<{ key: string; size: number; modifiedAt: string; contentType?: string }>; cursor?: string };
+
+test("reads only keys under the project's own prefix", () => {
+  assert.equal(isProjectArtifactKey("e2e", "projects/e2e/runs/run_1/manifest.json"), true);
+  assert.equal(isProjectArtifactKey("e2e", "projects/other/runs/run_1/manifest.json"), false);
+  assert.equal(isProjectArtifactKey("e2e", "projects/e2e/../other/secret.json"), false);
+  assert.equal(isProjectArtifactKey("my project", "projects/my%20project/spec/flow.yaml"), true);
+});
+
+test("lists the whole project by default and refuses a foreign prefix", () => {
+  assert.equal(normalizeArtifactPrefix("e2e", null), "projects/e2e/");
+  assert.equal(normalizeArtifactPrefix("e2e", "projects/e2e/runs/"), "projects/e2e/runs/");
+  assert.equal(normalizeArtifactPrefix("e2e", "projects/other/"), null);
+});
+
+test("accepts only the run's own manifest key", () => {
+  assert.equal(isRunManifestKey("e2e", "run_1", "projects/e2e/runs/run_1/manifest.json"), true);
+  assert.equal(isRunManifestKey("e2e", "run_1", "projects/e2e/runs/run_2/manifest.json"), false);
+  assert.equal(isRunManifestKey("e2e", "run_1", "e2e/runs/run_1"), false);
+  assert.equal(isRunManifestKey("e2e", "run_1", undefined), false);
+});
+
+test("reports unconfigured storage as 503", async () => {
+  const listed = await listProjectArtifacts(undefined, "e2e", url("/api/projects/e2e/artifacts"));
+  assert.equal(listed.status, 503);
+  assert.deepEqual(await listed.json(), { error: ARTIFACT_STORAGE_UNCONFIGURED });
+  assert.equal((await getProjectArtifact(undefined, "e2e", url("/api/projects/e2e/artifacts/object?key=projects/e2e/x"))).status, 503);
+});
+
+test("lists a project's artifacts page by page with a cursor", async () => {
+  const bucket = fakeBucket({
+    "projects/e2e/runs/run_1/manifest.json": { body: "{}", contentType: "application/json" },
+    "projects/e2e/runs/run_1/results.json": { body: "{}", contentType: "application/json" },
+    "projects/e2e/runs/run_1/artifacts/home.png": { body: "png", contentType: "image/png" },
+    "projects/other/runs/run_9/manifest.json": { body: "{}" },
+  }, 2);
+  const first = (await (await listProjectArtifacts(bucket, "e2e", url("/api/projects/e2e/artifacts?prefix=projects/e2e/runs/"))).json()) as ListBody;
+  assert.equal(first.objects.length, 2);
+  assert.equal(first.cursor, "2");
+  const second = (await (await listProjectArtifacts(bucket, "e2e", url(`/api/projects/e2e/artifacts?prefix=projects/e2e/runs/&cursor=${first.cursor}`))).json()) as ListBody;
+  assert.equal(second.objects.length, 1);
+  assert.equal(second.cursor, undefined);
+  const keys = [...first.objects, ...second.objects].map((object) => object.key);
+  assert.ok(keys.every((key) => key.startsWith("projects/e2e/")));
+  assert.equal((await listProjectArtifacts(bucket, "e2e", url("/api/projects/e2e/artifacts?prefix=projects/other/"))).status, 400);
+});
+
+test("streams an artifact with its content type, and 404s a missing one", async () => {
+  const bucket = fakeBucket({ "projects/e2e/runs/run_1/artifacts/home.png": { body: "png-bytes", contentType: "image/png" } });
+  const found = await getProjectArtifact(bucket, "e2e", url("/api/projects/e2e/artifacts/object?key=projects/e2e/runs/run_1/artifacts/home.png"));
+  assert.equal(found.status, 200);
+  assert.equal(found.headers.get("content-type"), "image/png");
+  assert.equal(await found.text(), "png-bytes");
+  assert.equal((await getProjectArtifact(bucket, "e2e", url("/api/projects/e2e/artifacts/object?key=projects/e2e/missing.png"))).status, 404);
+  assert.equal((await getProjectArtifact(bucket, "e2e", url("/api/projects/e2e/artifacts/object?key=projects/other/secret.png"))).status, 400);
+});