@taodigital/crawler 0.0.0-stage → 1.2.0

package/dist/job-queue.js

@@ -0,0 +1,3812 @@
+import { withTenant, prismaAdmin } from "@taodigital/database";
+import { crawlJobsTotal, crawlJobDurationSeconds } from "@taodigital/core";
+import { logger } from "./logger.js";
+import { AppBrain, buildArtifactKey, getTenantStorageConfig, uploadScreenshotToTenantStorage, uploadFileToTenantStorage, notifyRunCompletion, recordLLMCall, downloadBufferFromTenantStorage, dispatchToTenantAdmins } from "@taodigital/app-brain";
+async function notifyAdmins(tenantId, data) {
+  try {
+    await dispatchToTenantAdmins(tenantId, data);
+  } catch (e) {
+    console.error("[notify] failed:", e);
+  }
+}
+import { generateTaxonomySkillFiles, groupScreensWithAI, generateExecutionPlan, refreshTestCasesSkillFile, refreshTestDataSkillFile, refreshTestScriptSkillFile, refreshRequirementsCoverageSkillFile, refreshTestExecutionHistorySkillFile, refreshVisualRegressionHistorySkillFile, refreshLocatorStrategyWithHealingData, refreshFieldCatalogSkillFile, detectFieldsFromHtml, mergeIntoCatalog, generateArtifactIntelligence } from "@taodigital/agents";
+import { crawlProject, domFallbackElements, getNonHeadlessUserAgent } from "./crawler.js";
+import { httpCrawl } from "./http-engine.js";
+import { hashContent, normalizeText } from "./incremental-diff.js";
+import { discoverProjectUrls } from "./sitemap.js";
+import { executeExecutionStep, executeTestPlan } from "./test-executor.js";
+import { runNativeCrawl } from "./native-crawler.js";
+import { elementsToPlaywrightLocators } from "./locator-extractor.js";
+import { jira, confluence, figma } from "@taodigital/connectors";
+import { decrypt, config as platformConfig, dispatchWebhook, isFeatureEnabled, interpolatePlaceholders } from "@taodigital/core";
+import { createHmac } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { spawn } from "node:child_process";
+var FailureType = /* @__PURE__ */ ((FailureType2) => {
+  FailureType2["TRANSIENT"] = "TRANSIENT";
+  FailureType2["INFRASTRUCTURE"] = "INFRASTRUCTURE";
+  FailureType2["LOGICAL"] = "LOGICAL";
+  FailureType2["FATAL"] = "FATAL";
+  return FailureType2;
+})(FailureType || {});
+const BACKOFF_BY_TYPE = {
+  ["TRANSIENT" /* TRANSIENT */]: { maxRetries: 5, baseDelayMs: 3e4, multiplier: 2, maxDelayMs: 3e5 },
+  ["INFRASTRUCTURE" /* INFRASTRUCTURE */]: { maxRetries: 3, baseDelayMs: 6e4, multiplier: 3, maxDelayMs: 6e5 },
+  ["LOGICAL" /* LOGICAL */]: { maxRetries: 1, baseDelayMs: 12e4, multiplier: 1, maxDelayMs: 12e4 },
+  ["FATAL" /* FATAL */]: { maxRetries: 0, baseDelayMs: 0, multiplier: 1, maxDelayMs: 0 }
+};
+function classifyFailure(error) {
+  const msg = (error instanceof Error ? error.message : String(error)).toLowerCase();
+  if (msg.includes("master_enc_key") || msg.includes("missing secret") || msg.includes("invalid configuration")) {
+    return "FATAL" /* FATAL */;
+  }
+  if (msg.includes("out of memory") || msg.includes("heap out") || msg.includes("connection refused") || msg.includes("econnrefused") || msg.includes("prisma") || msg.includes("database") || msg.includes("worker exited") || msg.includes("sigkill")) {
+    return "INFRASTRUCTURE" /* INFRASTRUCTURE */;
+  }
+  if (msg.includes("validation") || msg.includes("invalid input") || msg.includes("not found") || msg.includes("unauthorized") || msg.includes("bad request") || msg.includes("400") || msg.includes("422") || msg.includes("403")) {
+    return "LOGICAL" /* LOGICAL */;
+  }
+  return "TRANSIENT" /* TRANSIENT */;
+}
+function computeNextRetryAt(failureType, retryCount) {
+  const config = BACKOFF_BY_TYPE[failureType];
+  if (retryCount >= config.maxRetries) return null;
+  const delayMs = Math.min(config.baseDelayMs * Math.pow(config.multiplier, retryCount), config.maxDelayMs);
+  return new Date(Date.now() + delayMs);
+}
+async function recordJobFailure(tenantId, jobId, err, checkpointData, options) {
+  const errorMessage = err instanceof Error ? err.message : String(err);
+  const aborted = options?.isAborted ?? (errorMessage.includes("CRAWL_ABORTED") || errorMessage.includes("Stopped by user"));
+  if (aborted) {
+    await prismaAdmin.platformJob.update({
+      where: { id: jobId },
+      data: {
+        status: "CANCELLED",
+        error: "Stopped by user",
+        finishedAt: /* @__PURE__ */ new Date(),
+        heartbeatAt: null,
+        workerId: null,
+        ...checkpointData ? { checkpoint: checkpointData, checkpointAt: /* @__PURE__ */ new Date() } : {}
+      }
+    }).catch(() => {
+    });
+    return;
+  }
+  const failureType = classifyFailure(err);
+  const jobRow = await prismaAdmin.platformJob.findUnique({
+    where: { id: jobId },
+    select: { retryCount: true, result: true }
+  }).catch(() => null);
+  const currentRetry = jobRow?.retryCount ?? 0;
+  const nextRetryAt = computeNextRetryAt(failureType, currentRetry);
+  const isFatal = !nextRetryAt || failureType === "FATAL" /* FATAL */;
+  await prismaAdmin.platformJob.update({
+    where: { id: jobId },
+    data: {
+      status: isFatal ? "FAILED" : "RETRY_WAIT",
+      error: errorMessage.slice(0, 2e3),
+      finishedAt: /* @__PURE__ */ new Date(),
+      heartbeatAt: null,
+      workerId: null,
+      nextRetryAt,
+      retryCount: { increment: 1 },
+      failureType,
+      dlq: isFatal,
+      dlqAt: isFatal ? /* @__PURE__ */ new Date() : null,
+      dlqReason: isFatal ? errorMessage.slice(0, 1e3) : null,
+      ...checkpointData ? { checkpoint: checkpointData, checkpointAt: /* @__PURE__ */ new Date() } : {},
+      result: {
+        ...jobRow?.result ?? {},
+        failureType,
+        ...checkpointData ? { checkpoint: checkpointData } : {}
+      }
+    }
+  }).catch((e) => logger.error({ err: e, jobId }, "[job-queue] failed to record job failure"));
+}
+function generateTOTP(secret) {
+  const BASE32 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+  const clean = secret.toUpperCase().replace(/\s/g, "").replace(/=/g, "");
+  let bits = 0, value = 0;
+  const bytes = [];
+  for (const ch of clean) {
+    const idx = BASE32.indexOf(ch);
+    if (idx === -1) continue;
+    value = value << 5 | idx;
+    bits += 5;
+    if (bits >= 8) {
+      bits -= 8;
+      bytes.push(value >> bits & 255);
+    }
+  }
+  const counter = Math.floor(Date.now() / 3e4);
+  const buf = Buffer.alloc(8);
+  buf.writeBigInt64BE(BigInt(counter));
+  const hmac = createHmac("sha1", Buffer.from(bytes)).update(buf).digest();
+  const offset = hmac[hmac.length - 1] & 15;
+  const code = (hmac[offset] & 127) << 24 | (hmac[offset + 1] & 255) << 16 | (hmac[offset + 2] & 255) << 8 | hmac[offset + 3] & 255;
+  return String(code % 1e6).padStart(6, "0");
+}
+function deriveFallbackTargetPath(ref, framework) {
+  const slug = (ref ?? "test").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "test";
+  const base = framework.startsWith("cypress") ? "cypress/e2e/" : framework === "playwright-py" || framework === "pytest" || framework === "selenium-py" ? "tests/" : framework === "playwright-java" || framework === "selenium-java" || framework === "junit" ? "src/test/java/" : "tests/";
+  const ext = framework === "playwright-py" || framework === "pytest" || framework === "selenium-py" ? "_test.py" : framework === "playwright-java" || framework === "selenium-java" || framework === "junit" ? "Test.java" : framework.includes("ts") ? ".spec.ts" : ".spec.js";
+  return `${base}${slug}${ext}`;
+}
+function makeJobName(type) {
+  const now = /* @__PURE__ */ new Date();
+  const date = now.toISOString().slice(0, 10);
+  const ts = now.getTime();
+  const label = type === "CRAWL" ? "Crawl" : type === "CAPTURE_STEPS" ? "CaptureSteps" : type === "NATIVE_CRAWL" ? "NativeCrawl" : type === "GENERATE_TESTS" ? "GenerateTests" : type === "VISUAL_REGRESSION" ? "VisualRegression" : type === "AI_EDIT" ? "AIEdit" : type === "API_TESTS" ? "ApiTests" : type === "SECURITY_TESTS" ? "SecurityTests" : type === "INTEGRATION_TESTS" ? "IntegrationTests" : type === "GENERATE_TESTS_FROM_REQS" ? "GenerateTestsFromReqs" : type === "GENERATE_DATA" ? "GenerateData" : type === "GENERATE_SCRIPT" ? "GenerateScript" : type === "GENERATE_TEST_PLAN" ? "GenerateTestPlan" : type === "IMPORT_TESTS" ? "ImportTests" : type === "GENERATE_SCREEN_TESTS" ? "GenerateScreenTests" : type === "BATCH_GENERATE_ALIGNED" ? "BatchGenerateAligned" : type === "CREATE_PR" ? "CreatePR" : type === "NEW_PAGES_PIPELINE" ? "NewPagesPipeline" : type.charAt(0) + type.slice(1).toLowerCase().replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+  return `${label}_${date}_${ts}`;
+}
+const runningControllers = /* @__PURE__ */ new Map();
+const WORKER_ID = `${os.hostname()}:${process.pid}`;
+const STALE_JOB_TIMEOUT_MINUTES = Number(process.env.JOB_STALE_TIMEOUT_MINUTES) || 30;
+const MAX_CONCURRENT_PER_TENANT = Number(process.env.MAX_CONCURRENT_PER_TENANT) || 4;
+const WORKER_POLL_INTERVAL_MS = Number(process.env.JOB_WORKER_POLL_INTERVAL_MS) || 15e3;
+const WORKER_CONCURRENCY = Number(process.env.JOB_WORKER_CONCURRENCY) || 8;
+let activeExecutions = 0;
+function withSemaphore(fn) {
+  activeExecutions++;
+  return fn().finally(() => {
+    activeExecutions--;
+  });
+}
+function getActiveExecutionCount() {
+  return activeExecutions;
+}
+const MAX_CONCURRENT_DISCOVER = Number(process.env.MAX_CONCURRENT_DISCOVER) || 2;
+const JOB_HEARTBEAT_INTERVAL_MS = Number(process.env.JOB_HEARTBEAT_INTERVAL_MS) || 15e3;
+const TEST_EXEC_CONCURRENCY = Number(process.env.TEST_EXEC_CONCURRENCY) || 5;
+let jobDispatchTable = null;
+async function claimSpecificJob(jobId) {
+  const rows = await prismaAdmin.$queryRaw`
+    UPDATE "PlatformJob"
+    SET status = 'RUNNING', "startedAt" = NOW(), "heartbeatAt" = NOW(), "workerId" = ${WORKER_ID}
+    WHERE id = ${jobId} AND status = 'QUEUED'
+      AND ("nextRetryAt" IS NULL OR "nextRetryAt" <= NOW())
+    RETURNING id, "tenantId" AS "tenantId", "projectId" AS "projectId", type, config
+  `;
+  return rows[0] ?? null;
+}
+async function claimNextQueuedJob() {
+  const maxDiscover = MAX_CONCURRENT_DISCOVER;
+  const rows = await prismaAdmin.$queryRaw`
+    UPDATE "PlatformJob"
+    SET status = 'RUNNING', "startedAt" = NOW(), "heartbeatAt" = NOW(), "workerId" = ${WORKER_ID}
+    WHERE id = (
+      SELECT id FROM "PlatformJob" p
+      WHERE status = 'QUEUED'
+        AND ("nextRetryAt" IS NULL OR "nextRetryAt" <= NOW())
+        AND (
+          type != 'DISCOVER'
+          OR (SELECT COUNT(*) FROM "PlatformJob" WHERE status = 'RUNNING' AND type = 'DISCOVER') < ${maxDiscover}
+        )
+        AND (
+          SELECT COUNT(*) FROM "PlatformJob" p2
+          WHERE p2.status = 'RUNNING'
+            AND p2."tenantId" = p."tenantId"
+            AND p2.inline = false
+        ) < ${MAX_CONCURRENT_PER_TENANT}
+      ORDER BY p."priority" DESC, p."queuedAt" ASC
+      FOR UPDATE SKIP LOCKED
+      LIMIT 1
+    )
+    RETURNING id, "tenantId" AS "tenantId", "projectId" AS "projectId", type, config
+  `;
+  return rows[0] ?? null;
+}
+async function requeueStaleRunningJobs() {
+  const failedRows = await prismaAdmin.$queryRaw`
+    UPDATE "PlatformJob"
+    SET status = 'FAILED',
+        "finishedAt" = NOW(),
+        error = 'API process was restarted while this job was running — please retry from the UI.'
+    WHERE status = 'RUNNING'
+      AND type IN ('GENERATE_SCRIPT', 'GENERATE_DATA', 'GENERATE_TESTS', 'GENERATE_TEST_PLAN')
+      AND COALESCE("heartbeatAt", "startedAt") < (NOW() AT TIME ZONE 'UTC') - (${STALE_JOB_TIMEOUT_MINUTES} * interval '1 minute')
+    RETURNING id
+  `;
+  if (failedRows.length > 0) {
+    logger.warn({ jobIds: failedRows.map((r) => r.id), staleTimeoutMinutes: STALE_JOB_TIMEOUT_MINUTES }, "[job-worker] failed stale API-in-process job(s) \u2014 API restarted while running");
+  }
+  const rows = await prismaAdmin.$queryRaw`
+    UPDATE "PlatformJob"
+    SET status = 'QUEUED',
+        "workerId" = NULL,
+        result = jsonb_set(
+          COALESCE(result::jsonb, '{}'::jsonb),
+          '{step}',
+          to_jsonb('Worker heartbeat lost — queued for recovery'::text),
+          true
+        )
+    WHERE status = 'RUNNING'
+      AND type NOT IN ('GENERATE_SCRIPT', 'GENERATE_DATA', 'GENERATE_TESTS', 'GENERATE_TEST_PLAN')
+      AND COALESCE("heartbeatAt", "startedAt") < (NOW() AT TIME ZONE 'UTC') - (${STALE_JOB_TIMEOUT_MINUTES} * interval '1 minute')
+    RETURNING id
+  `;
+  if (rows.length > 0) {
+    logger.warn({ jobIds: rows.map((r) => r.id), staleTimeoutMinutes: STALE_JOB_TIMEOUT_MINUTES }, "[job-worker] requeued stale RUNNING job(s)");
+  }
+}
+async function requeueOrphanedJobs() {
+  const rows = await prismaAdmin.$queryRaw`
+    UPDATE "PlatformJob"
+    SET status = 'QUEUED',
+        "workerId" = NULL,
+        result = jsonb_set(
+          COALESCE(result::jsonb, '{}'::jsonb),
+          '{step}',
+          to_jsonb('Worker restarted — queued for recovery'::text),
+          true
+        )
+    WHERE status = 'RUNNING'
+      AND "workerId" IS NOT NULL
+      AND "workerId" != ${WORKER_ID}
+    RETURNING id
+  `;
+  if (rows.length > 0) {
+    logger.warn({ jobIds: rows.map((r) => r.id), workerId: WORKER_ID }, "[job-worker] requeued orphaned RUNNING job(s) from dead worker");
+  }
+}
+async function dispatchClaimedJob(job) {
+  const dispatcher = jobDispatchTable?.[job.type];
+  if (!dispatcher) {
+    logger.error({ jobId: job.id, type: job.type }, "[job-worker] no dispatcher registered for job type");
+    await prismaAdmin.platformJob.update({
+      where: { id: job.id },
+      data: { status: "FAILED", error: `Unknown job type: ${job.type}`, finishedAt: /* @__PURE__ */ new Date() }
+    }).catch(() => {
+    });
+    return;
+  }
+  const stopTimer = crawlJobDurationSeconds.startTimer({ type: job.type });
+  try {
+    await dispatcher(job.id, job.config);
+    stopTimer();
+    const finished = await prismaAdmin.platformJob.findUnique({ where: { id: job.id }, select: { status: true } }).catch(() => null);
+    crawlJobsTotal.inc({ type: job.type, status: finished?.status === "FAILED" || finished?.status === "RETRY_WAIT" ? "failed" : "success" });
+  } catch (err) {
+    stopTimer();
+    crawlJobsTotal.inc({ type: job.type, status: "failed" });
+    logger.error({ jobId: job.id, type: job.type, err: String(err?.message ?? err) }, "[job-worker] job threw uncaught error");
+    await recordJobFailure(job.tenantId, job.id, err);
+  }
+}
+let workerLoopTimer = null;
+let workerShuttingDown = false;
+async function retryEligibleFailedJobs() {
+  const rows = await prismaAdmin.$queryRaw`
+    UPDATE "PlatformJob"
+    SET status = 'RETRY_WAIT',
+        "retryCount" = "retryCount" + 1,
+        "nextRetryAt" = NOW() + (INTERVAL '1 minute' * POWER(2, "retryCount")),
+        "workerId" = NULL
+    WHERE status = 'FAILED'
+      AND dlq = false
+      AND "nextRetryAt" IS NULL
+      AND "retryCount" < 5
+    RETURNING id
+  `;
+  if (rows.length > 0) {
+    logger.info({ jobIds: rows.map((r) => r.id) }, "[job-worker] moved failed job(s) to RETRY_WAIT");
+  }
+  const readyRows = await prismaAdmin.$queryRaw`
+    UPDATE "PlatformJob"
+    SET status = 'QUEUED',
+        "requeuedAt" = NOW()
+    WHERE status = 'RETRY_WAIT'
+      AND "nextRetryAt" <= (NOW() AT TIME ZONE 'UTC')
+      AND dlq = false
+    RETURNING id
+  `;
+  if (readyRows.length > 0) {
+    logger.info({ jobIds: readyRows.map((r) => r.id) }, "[job-worker] promoted RETRY_WAIT job(s) to QUEUED");
+  }
+}
+async function promoteToDeadLetterQueue() {
+  const rows = await prismaAdmin.$queryRaw`
+    UPDATE "PlatformJob"
+    SET dlq = true,
+        "dlqAt" = NOW(),
+        "dlqReason" = error
+    WHERE status = 'FAILED'
+      AND dlq = false
+      AND "retryCount" >= CASE
+        WHEN type IN ('CRAWL', 'NATIVE_CRAWL') THEN 3
+        WHEN type IN ('GENERATE_TESTS', 'IMPORT_TESTS', 'RUN_TEST_SUITE', 'VISUAL_REGRESSION') THEN 2
+        WHEN type IN ('GENERATE_SCRIPT', 'GENERATE_DATA', 'GENERATE_TEST_PLAN') THEN 0
+        ELSE 1
+      END
+    RETURNING id
+  `;
+  if (rows.length > 0) {
+    logger.error({ jobIds: rows.map((r) => r.id) }, "[job-worker] promoted failed job(s) to DLQ");
+  }
+}
+function startJobWorkerLoop(opts) {
+  if (workerLoopTimer) return;
+  const pollIntervalMs = opts?.pollIntervalMs ?? WORKER_POLL_INTERVAL_MS;
+  const concurrency = opts?.concurrency ?? WORKER_CONCURRENCY;
+  logger.info({ workerId: WORKER_ID, pollIntervalMs, concurrency }, "[job-worker] starting");
+  const sweepTick = async () => {
+    try {
+      await retryEligibleFailedJobs();
+      await promoteToDeadLetterQueue();
+      await requeueStaleRunningJobs();
+    } catch (err) {
+      logger.error({ err: String(err) }, "[job-worker] stale/retry job sweep failed");
+    }
+  };
+  workerLoopTimer = setInterval(sweepTick, pollIntervalMs);
+  workerShuttingDown = false;
+  const pollLoop = async () => {
+    void sweepTick();
+    while (!workerShuttingDown) {
+      if (activeExecutions >= concurrency) {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        continue;
+      }
+      let paused = false;
+      try {
+        const pauseRow = await prismaAdmin.systemConfig.findUnique({ where: { key: "queue.paused" } });
+        paused = pauseRow?.value === "true";
+      } catch {
+      }
+      if (paused) {
+        logger.info("[job-worker] queue is paused \u2014 skipping claim");
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+        continue;
+      }
+      let job = null;
+      try {
+        job = await claimNextQueuedJob();
+      } catch (err) {
+        logger.error({ err: String(err) }, "[job-worker] claim failed");
+      }
+      if (!job) {
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+        continue;
+      }
+      withSemaphore(() => dispatchClaimedJob(job)).catch((err) => {
+        logger.error({ err, jobId: job.id }, "[worker] unhandled job error");
+      });
+    }
+  };
+  void pollLoop();
+}
+function stopJobWorkerLoop() {
+  workerShuttingDown = true;
+  if (workerLoopTimer) clearInterval(workerLoopTimer);
+  workerLoopTimer = null;
+}
+async function createTrackedJob(type, config) {
+  const name = makeJobName(type);
+  const job = await withTenant(
+    config.tenantId,
+    (tx) => tx.platformJob.create({
+      data: { tenantId: config.tenantId, projectId: config.projectId, type, name, status: "RUNNING", startedAt: /* @__PURE__ */ new Date(), inline: true, config }
+    })
+  );
+  return job.id;
+}
+async function finishTrackedJob(tenantId, jobId, error) {
+  if (!error) {
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({ where: { id: jobId }, data: { status: "DONE", finishedAt: /* @__PURE__ */ new Date(), progress: 100 } })
+    ).catch(() => {
+    });
+    return;
+  }
+  const failureType = classifyFailure(error);
+  const jobRow = await prismaAdmin.platformJob.findUnique({ where: { id: jobId }, select: { retryCount: true, result: true } }).catch(() => null);
+  const currentRetry = jobRow?.retryCount ?? 0;
+  const nextRetryAt = computeNextRetryAt(failureType, currentRetry);
+  await withTenant(
+    tenantId,
+    (tx) => tx.platformJob.update({
+      where: { id: jobId },
+      data: {
+        status: nextRetryAt ? "RETRY_WAIT" : "FAILED",
+        finishedAt: /* @__PURE__ */ new Date(),
+        error,
+        nextRetryAt,
+        retryCount: { increment: 1 },
+        failureType,
+        result: { ...jobRow?.result ?? {}, failureType }
+      }
+    })
+  ).catch(() => {
+  });
+  if (!nextRetryAt || failureType === "FATAL" /* FATAL */) {
+    await prismaAdmin.platformJob.update({
+      where: { id: jobId },
+      data: { dlq: true, dlqAt: /* @__PURE__ */ new Date(), dlqReason: error }
+    }).catch(() => {
+    });
+  }
+}
+async function enqueueJob(type, config) {
+  const { tenantId, projectId, submittedBy } = config;
+  const name = makeJobName(type);
+  const job = await withTenant(
+    tenantId,
+    (tx) => tx.platformJob.create({
+      data: {
+        tenantId,
+        projectId,
+        type,
+        name,
+        status: "QUEUED",
+        config,
+        ...submittedBy ? { submittedBy } : {}
+      }
+    })
+  );
+  if (process.env.JOB_QUEUE_BACKEND === "sqs") {
+    const { sendJobToSqs } = await import("./sqs-queue.js");
+    await sendJobToSqs(job.id);
+  } else if (process.env.DISABLE_WORKER !== "true") {
+    setImmediate(() => claimSpecificJob(job.id).then((claimed) => claimed && dispatchClaimedJob(claimed)));
+  }
+  return job.id;
+}
+async function getJob(tenantId, jobId) {
+  return withTenant(
+    tenantId,
+    (tx) => tx.platformJob.findFirst({ where: { id: jobId, tenantId } })
+  );
+}
+async function listJobs(tenantId, projectId) {
+  return withTenant(tenantId, async (tx) => {
+    const jobs = await tx.platformJob.findMany({
+      where: { tenantId, projectId },
+      orderBy: { queuedAt: "desc" },
+      take: 50
+    });
+    const jobIds = jobs.map((j) => j.id);
+    if (jobIds.length === 0) return jobs;
+    const modelRows = await tx.lLMCallLog.groupBy({
+      by: ["jobId"],
+      where: { tenantId, jobId: { in: jobIds } },
+      _max: { model: true, calledAt: true }
+    });
+    const modelByJobId = new Map(
+      modelRows.filter((r) => r.jobId && r._max?.model).map((r) => [r.jobId, r._max.model])
+    );
+    return jobs.map((j) => ({ ...j, llmModel: modelByJobId.get(j.id) ?? null }));
+  });
+}
+async function cancelJob(tenantId, jobId) {
+  const controller = runningControllers.get(jobId);
+  if (controller) {
+    controller.abort();
+    runningControllers.delete(jobId);
+  }
+  await withTenant(
+    tenantId,
+    (tx) => tx.platformJob.update({
+      where: { id: jobId },
+      data: { status: "CANCEL_REQUESTED" }
+    })
+  );
+}
+async function rerunJob(tenantId, jobId) {
+  const job = await withTenant(
+    tenantId,
+    (tx) => tx.platformJob.findUnique({ where: { id: jobId } })
+  );
+  if (!job) throw new Error("Job not found");
+  return enqueueJob(job.type, { ...job.config, tenantId });
+}
+const jobCheckpoints = /* @__PURE__ */ new Map();
+async function resumeJob(tenantId, jobId) {
+  const job = await withTenant(
+    tenantId,
+    (tx) => tx.platformJob.findUnique({ where: { id: jobId } })
+  );
+  if (!job) throw new Error("Job not found");
+  const checkpoint = job.checkpoint ?? job.result?.checkpoint;
+  const visitedUrls = checkpoint?.visitedUrls ?? [];
+  const pendingQueue = checkpoint?.pendingQueue ?? [];
+  if (pendingQueue.length === 0 && visitedUrls.length === 0) {
+    return enqueueJob(job.type, { ...job.config, tenantId });
+  }
+  return enqueueJob(job.type, {
+    ...job.config,
+    tenantId,
+    skipUrls: [...job.config?.skipUrls ?? [], ...visitedUrls],
+    startUrls: pendingQueue.length > 0 ? pendingQueue : job.config?.startUrls
+  });
+}
+async function updateJobProgress(tenantId, jobId, progress, step) {
+  try {
+    await withTenant(tenantId, async (tx) => {
+      const current = await tx.platformJob.findUnique({
+        where: { id: jobId },
+        select: { status: true }
+      });
+      if (current?.status === "CANCELLED" || current?.status === "CANCEL_REQUESTED") {
+        runningControllers.get(jobId)?.abort();
+        runningControllers.delete(jobId);
+        return;
+      }
+      await tx.platformJob.update({
+        where: { id: jobId },
+        // GAP-09: write currentStep as a proper column in addition to result.step (backward compat)
+        data: { progress, currentStep: step, result: { step }, heartbeatAt: /* @__PURE__ */ new Date() }
+      });
+    });
+  } catch {
+  }
+}
+async function heartbeatJob(tenantId, jobId) {
+  try {
+    await withTenant(tenantId, async (tx) => {
+      const current = await tx.platformJob.findUnique({
+        where: { id: jobId },
+        select: { status: true }
+      });
+      if (current?.status === "CANCELLED" || current?.status === "CANCEL_REQUESTED") {
+        runningControllers.get(jobId)?.abort();
+        runningControllers.delete(jobId);
+        return;
+      }
+      if (current?.status !== "RUNNING") return;
+      await tx.platformJob.update({
+        where: { id: jobId },
+        data: { heartbeatAt: /* @__PURE__ */ new Date(), workerId: WORKER_ID }
+      });
+    });
+  } catch {
+  }
+}
+async function investigateScreenChanges(tenantId, projectId, changedScreens) {
+  const [jiraCfg, confluenceCfg] = await Promise.all([
+    AppBrain.getConnectorConfig(tenantId, projectId, "JIRA"),
+    AppBrain.getConnectorConfig(tenantId, projectId, "CONFLUENCE")
+  ]);
+  for (const screen of changedScreens) {
+    const searchTerm = screen.url ?? screen.name;
+    const changeSummary = `Screen "${screen.name}" changed: +${screen.addedElements.length} elements, -${screen.removedElements.length} elements`;
+    const detail = {
+      screenId: screen.id,
+      screenName: screen.name,
+      url: screen.url,
+      addedElements: screen.addedElements,
+      removedElements: screen.removedElements,
+      jiraTickets: [],
+      confluencePages: []
+    };
+    if (jiraCfg?.baseUrl && jiraCfg?.email && jiraCfg?.apiToken) {
+      try {
+        detail.jiraTickets = await jira.searchIssues(
+          { baseUrl: jiraCfg.baseUrl, email: jiraCfg.email, apiToken: jiraCfg.apiToken, projectKey: jiraCfg.projectKey },
+          searchTerm
+        );
+      } catch (e) {
+        logger.warn({ searchTerm, err: e }, "Jira search failed");
+      }
+    }
+    if (confluenceCfg?.baseUrl && confluenceCfg?.email && confluenceCfg?.apiToken) {
+      try {
+        detail.confluencePages = await confluence.searchPages(
+          { baseUrl: confluenceCfg.baseUrl, email: confluenceCfg.email, apiToken: confluenceCfg.apiToken, spaceKey: confluenceCfg.spaceKey },
+          searchTerm
+        );
+      } catch (e) {
+        logger.warn({ searchTerm, err: e }, "Confluence search failed");
+      }
+    }
+    await AppBrain.logChange(tenantId, projectId, "MODIFIED", changeSummary, detail);
+    logger.info({ screen: screen.name, jiraTickets: detail.jiraTickets.length, confluencePages: detail.confluencePages.length }, "Logged screen change investigation");
+  }
+}
+async function processJob(jobId, config, opts) {
+  const { tenantId, projectId } = config;
+  const jobStartedAt = /* @__PURE__ */ new Date();
+  const claimed = await withTenant(
+    tenantId,
+    (tx) => tx.platformJob.updateMany({
+      where: { id: jobId, status: { not: "CANCELLED" } },
+      data: { status: "RUNNING", startedAt: jobStartedAt, heartbeatAt: jobStartedAt, workerId: WORKER_ID }
+    })
+  );
+  if (claimed.count === 0) return;
+  const controller = new AbortController();
+  runningControllers.set(jobId, controller);
+  const heartbeatTimer = setInterval(() => {
+    void heartbeatJob(tenantId, jobId);
+  }, JOB_HEARTBEAT_INTERVAL_MS);
+  const onProgress = async (pct, step) => {
+    await updateJobProgress(tenantId, jobId, pct, step);
+    await opts?.onProgress?.(pct);
+  };
+  const DEFAULT_MAX_SCREENS = parseInt(process.env.CRAWL_DEFAULT_MAX_SCREENS ?? "") || 150;
+  try {
+    if (!config.maxScreens || !config.deviceProfiles || config.interactive === void 0 || config.useSitemap === void 0 || !config.traversalStrategy) {
+      const proj = await withTenant(
+        tenantId,
+        (tx) => tx.project.findUnique({ where: { id: projectId }, select: { crawlConfig: true } })
+      );
+      const perProject = proj?.crawlConfig?.maxScreens;
+      if (!config.maxScreens) config.maxScreens = perProject || DEFAULT_MAX_SCREENS;
+      if (!config.deviceProfiles) config.deviceProfiles = proj?.crawlConfig?.deviceProfiles ?? ["DESKTOP"];
+      if (config.interactive === void 0) config.interactive = proj?.crawlConfig?.interactive ?? false;
+      if (config.useSitemap === void 0) config.useSitemap = proj?.crawlConfig?.useSitemap ?? false;
+      if (!config.sitemapUrl) config.sitemapUrl = proj?.crawlConfig?.sitemapUrl ?? void 0;
+      if (!config.traversalStrategy) config.traversalStrategy = proj?.crawlConfig?.traversalStrategy ?? "BFS";
+      if (!config.bestFirstKeywords) config.bestFirstKeywords = proj?.crawlConfig?.bestFirstKeywords ?? void 0;
+      if (!config.segmentSize) config.segmentSize = proj?.crawlConfig?.segmentSize ?? 9999999;
+      if (!config.selectiveUrls?.length && (!config.startUrls || config.startUrls.length === 0)) {
+        const saved = proj?.crawlConfig?.seedUrls ?? [];
+        if (saved.length > 0) config.startUrls = saved;
+      }
+      if (config.interactive === void 0) config.interactive = proj?.crawlConfig?.interactive ?? false;
+    }
+    const runtimeCreds = config.credentials ? {
+      ...config.credentials,
+      ...config.credentials.totpSecret ? { getOneTimeCode: async () => generateTOTP(config.credentials.totpSecret) } : {}
+    } : void 0;
+    const storageConfigForCrawl = await getTenantStorageConfig(tenantId).catch(() => null);
+    const result = await crawlProject({
+      ...config,
+      credentials: runtimeCreds,
+      abortSignal: controller.signal,
+      jobId,
+      storageConfig: storageConfigForCrawl,
+      onCheckpoint: async (visitedUrls, pendingQueue) => {
+        jobCheckpoints.set(jobId, { visitedUrls, pendingQueue });
+        const CHECKPOINT_INTERVAL = parseInt(process.env.CRAWL_CHECKPOINT_INTERVAL ?? "10");
+        if (visitedUrls.length % CHECKPOINT_INTERVAL === 0) {
+          try {
+            await prismaAdmin.platformJob.update({
+              where: { id: jobId },
+              data: {
+                checkpoint: { visitedUrls, pendingQueue },
+                checkpointAt: /* @__PURE__ */ new Date()
+              }
+            });
+          } catch {
+          }
+        }
+      }
+    }, onProgress);
+    jobCheckpoints.delete(jobId);
+    const pendingUrls = result?.pendingUrls ?? [];
+    let nextJobId;
+    if (pendingUrls.length > 0) {
+      const visitedForSkip = result.visitedUrls ?? (result.discovered ?? []).filter((d) => !!d.screenId && !!d.url).map((d) => {
+        try {
+          const _u = new URL(d.url);
+          _u.hash = "";
+          return _u.href;
+        } catch {
+          return d.url;
+        }
+      });
+      const reason = result.wasTimeout ? "timeout" : "segment-limit";
+      logger.info({ pendingUrls: pendingUrls.length, visited: visitedForSkip.length, reason }, "[crawl] auto-enqueuing continuation job");
+      nextJobId = await enqueueJob("CRAWL", {
+        ...config,
+        startUrls: pendingUrls,
+        skipUrls: [...config.skipUrls ?? [], ...visitedForSkip]
+      }).catch((autoErr) => {
+        logger.warn({ err: autoErr?.message }, "[crawl] auto-segment enqueue failed (non-fatal)");
+        return void 0;
+      });
+    }
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({
+        where: { id: jobId },
+        data: {
+          status: "DONE",
+          result: { ...result, ...nextJobId ? { nextJobId } : {} },
+          progress: 100,
+          finishedAt: /* @__PURE__ */ new Date()
+        }
+      })
+    );
+    try {
+      const priorJob = await prismaAdmin.platformJob.findFirst({
+        where: { tenantId, projectId, type: "CRAWL", status: "DONE", id: { not: jobId } },
+        orderBy: { finishedAt: "desc" }
+      });
+      if (priorJob) {
+        await prismaAdmin.platformJob.create({
+          data: { tenantId, projectId, type: "CRAWL_DIFF", name: `crawl-diff-${priorJob.id.slice(-6)}-${jobId.slice(-6)}`, status: "QUEUED", config: { fromJobId: priorJob.id, toJobId: jobId } }
+        });
+      }
+    } catch (_) {
+    }
+    clearInterval(heartbeatTimer);
+    runningControllers.delete(jobId);
+    {
+      const crawledUrls = (result.discovered ?? []).filter((d) => !!d.screenId && !!d.url).map((d) => d.url);
+      if (crawledUrls.length > 0) {
+        (async () => {
+          const cfg = await AppBrain.getCrawlConfig(tenantId, projectId);
+          const existing = cfg?.seedUrls ?? [];
+          const merged = Array.from(/* @__PURE__ */ new Set([...existing, ...crawledUrls]));
+          if (merged.length > existing.length) {
+            await AppBrain.saveCrawlConfig(tenantId, projectId, { seedUrls: merged });
+            logger.info({ added: merged.length - existing.length, total: merged.length }, "[crawl] auto-seeded crawled URLs into crawlConfig.seedUrls");
+          }
+        })().catch((err) => logger.warn({ err: err?.message }, "[crawl] auto-seed seedUrls failed (non-fatal)"));
+      }
+      notifyAdmins(tenantId, {
+        type: "crawl.done",
+        title: "Crawl completed",
+        body: `Crawl for project finished successfully.`,
+        metadata: { projectId, jobId }
+      }).catch(console.error);
+      dispatchWebhook(tenantId, projectId, "crawl.done", {
+        jobId,
+        screensFound: result?.screensFound ?? result?.screens?.length ?? 0
+      }).catch(console.error);
+    }
+    setTimeout(() => {
+      aggregateJobTokens(tenantId, jobId, projectId, jobStartedAt).catch(console.error);
+    }, 8e3);
+    setImmediate(async () => {
+      try {
+        const projectMap = await AppBrain.getProjectMap(tenantId, projectId);
+        if (projectMap?.screens?.length) {
+          const screenCount = projectMap.screens.length;
+          if (screenCount > 300) {
+            await withTenant(
+              tenantId,
+              (tx) => tx.project.update({ where: { id: projectId }, data: { oversized: true } })
+            );
+          }
+          await generateTaxonomySkillFiles(tenantId, projectId, projectMap.screens, result.apiEndpoints, result.performanceMetrics);
+          try {
+            const { readFile } = await import("node:fs/promises");
+            const { existsSync } = await import("node:fs");
+            const screensWithDom = projectMap.screens.filter((s) => s.domSnapshotPath);
+            const detectLimit = Math.min(screensWithDom.length, 20);
+            let fieldDetectAdded = 0;
+            for (let si = 0; si < detectLimit; si++) {
+              const screen = screensWithDom[si];
+              try {
+                let htmlContent = null;
+                const domPath = screen.domSnapshotPath;
+                if (domPath.startsWith("https://") || domPath.startsWith("http://")) {
+                  const res = await fetch(domPath);
+                  if (res.ok) htmlContent = await res.text();
+                } else if (existsSync(domPath)) {
+                  htmlContent = await readFile(domPath, "utf8");
+                }
+                if (!htmlContent) continue;
+                const detected = await detectFieldsFromHtml({ tenantId, projectId, html: htmlContent });
+                if (detected.length > 0) {
+                  const merged = await mergeIntoCatalog({ tenantId, projectId, detected });
+                  fieldDetectAdded += merged.added;
+                }
+              } catch (sErr) {
+                logger.warn({ screenId: screen.id, err: sErr }, "[field-detect] skipped screen");
+              }
+            }
+            if (fieldDetectAdded > 0 || detectLimit > 0) {
+              logger.info({ screens: detectLimit, added: fieldDetectAdded, projectId }, "[field-detect] catalog populated from crawl");
+              refreshFieldCatalogSkillFile(tenantId, projectId).catch(console.error);
+            }
+          } catch (fdErr) {
+            logger.warn({ err: fdErr }, "[field-detect] post-crawl field detection failed");
+          }
+          const tenantStorageCfg = await getTenantStorageConfig(tenantId).catch(() => null);
+          if (tenantStorageCfg) {
+            let uploaded = 0;
+            for (const screen of projectMap.screens) {
+              for (const shot of screen.screenshots ?? []) {
+                if (!shot.storagePath || shot.cloudUrl) continue;
+                try {
+                  const filename = `${screen.id}-v${shot.version}.png`;
+                  const key = buildArtifactKey(tenantId, projectId, "screenshots", filename, tenantStorageCfg.prefix);
+                  const cloudUrl = await uploadScreenshotToTenantStorage(tenantStorageCfg, shot.storagePath, key);
+                  await AppBrain.updateScreenshotCloudUrl(tenantId, shot.id, cloudUrl);
+                  uploaded++;
+                } catch (uploadErr) {
+                  logger.warn({ screenId: screen.id, err: uploadErr }, "Failed to upload screenshot to cloud storage");
+                }
+              }
+            }
+            if (uploaded > 0) logger.info({ uploaded, provider: tenantStorageCfg.provider }, "Uploaded screenshots to cloud storage");
+            const { existsSync } = await import("node:fs");
+            let domUploaded = 0;
+            let mdUploaded = 0;
+            for (const screen of projectMap.screens) {
+              const domPath = screen.domSnapshotPath;
+              if (domPath && !domPath.startsWith("https://") && existsSync(domPath)) {
+                try {
+                  const key = buildArtifactKey(tenantId, projectId, "dom-snapshots", `${screen.id}.json`, tenantStorageCfg.prefix);
+                  const cloudUrl = await uploadFileToTenantStorage(tenantStorageCfg, domPath, key, "application/json");
+                  await AppBrain.updateScreenDomSnapshot(tenantId, screen.id, domPath, cloudUrl);
+                  domUploaded++;
+                } catch (err) {
+                  logger.warn({ screenId: screen.id, err }, "Failed to upload DOM snapshot to cloud storage");
+                }
+              }
+              const mdPath = screen.markdownPath;
+              if (mdPath && !mdPath.startsWith("https://") && existsSync(mdPath)) {
+                try {
+                  const key = buildArtifactKey(tenantId, projectId, "markdown", `${screen.id}.md`, tenantStorageCfg.prefix);
+                  const cloudUrl = await uploadFileToTenantStorage(tenantStorageCfg, mdPath, key, "text/markdown");
+                  await AppBrain.updateScreenMarkdownPath(tenantId, screen.id, cloudUrl);
+                  mdUploaded++;
+                } catch (err) {
+                  logger.warn({ screenId: screen.id, err }, "Failed to upload markdown to cloud storage");
+                }
+              }
+            }
+            if (domUploaded > 0) logger.info({ domUploaded, provider: tenantStorageCfg.provider }, "Uploaded DOM snapshots to cloud storage");
+            if (mdUploaded > 0) logger.info({ mdUploaded, provider: tenantStorageCfg.provider }, "Uploaded markdown to cloud storage");
+          }
+          await groupScreensWithAI(tenantId, projectId, projectMap.screens, jobId, jobStartedAt);
+          try {
+            await withTenant(tenantId, async (tx) => {
+              const staleTests = await tx.$queryRaw`
+                SELECT tc.id
+                FROM "TestCase" tc
+                JOIN "Screen" s ON tc."screenId" = s.id
+                WHERE tc."tenantId" = ${tenantId}
+                  AND s."projectId" = ${projectId}
+                  AND s."elementHashChangedAt" IS NOT NULL
+                  AND tc."createdAt" IS NOT NULL
+                  AND s."elementHashChangedAt" > tc."createdAt"
+                  AND tc.status != 'PENDING_REVIEW'
+                  AND tc.status != 'RETIRED'
+              `;
+              if (staleTests.length > 0) {
+                const ids = staleTests.map((t) => t.id);
+                await tx.testCase.updateMany({
+                  where: { id: { in: ids } },
+                  data: { status: "PENDING_REVIEW" }
+                });
+                logger.info({ count: staleTests.length, projectId }, "Auto-flagged stale test cases as PENDING_REVIEW");
+              }
+            });
+          } catch (staleErr) {
+            logger.warn({ err: staleErr }, "Failed to auto-flag stale tests");
+          }
+          const changed = projectMap.screens.filter((s) => s.hasChange);
+          if (changed.length > 0) {
+            await investigateScreenChanges(tenantId, projectId, changed);
+          }
+        }
+      } catch (skillErr) {
+        logger.error({ projectId, err: skillErr }, "Taxonomy generation failed");
+      }
+    });
+  } catch (err) {
+    clearInterval(heartbeatTimer);
+    runningControllers.delete(jobId);
+    const aborted = String(err).includes("CRAWL_ABORTED");
+    const authFailure = !aborted && (String(err).includes("AUTH_FAILURE") || String(err).includes("SESSION_EXPIRED"));
+    const checkpoint = jobCheckpoints.get(jobId);
+    jobCheckpoints.delete(jobId);
+    if (authFailure && (checkpoint?.pendingQueue?.length ?? 0) > 0) {
+      const pendingAfterAuth = checkpoint.pendingQueue;
+      logger.info({ pending: pendingAfterAuth.length }, "[crawl] auth failure mid-crawl \u2014 auto-enqueuing continuation with pending URLs");
+      enqueueJob("CRAWL", {
+        ...config,
+        startUrls: pendingAfterAuth,
+        skipUrls: [...config.skipUrls ?? [], ...checkpoint.visitedUrls ?? []]
+      }).catch((enqErr) => logger.warn({ err: enqErr?.message }, "[crawl] auth-failure auto-segment enqueue failed (non-fatal)"));
+    }
+    await recordJobFailure(tenantId, jobId, err, checkpoint, { isAborted: aborted });
+    if (!aborted) {
+      notifyAdmins(tenantId, {
+        type: "crawl.failed",
+        title: "Crawl failed",
+        body: `Crawl for project failed: ${String(err)}`,
+        metadata: { projectId, jobId, error: String(err) }
+      }).catch(console.error);
+      dispatchWebhook(tenantId, projectId, "crawl.failed", {
+        jobId,
+        error: String(err)
+      }).catch(console.error);
+    }
+  } finally {
+    runningControllers.delete(jobId);
+  }
+}
+async function aggregateJobTokens(tenantId, jobId, projectId, startedAt) {
+  try {
+    await withTenant(tenantId, async (tx) => {
+      const rows = await tx.$queryRaw`
+        SELECT
+          COALESCE(SUM("promptTokens"), 0)::INT     AS "totalPromptTokens",
+          COALESCE(SUM("completionTokens"), 0)::INT AS "totalCompletionTokens",
+          COALESCE(SUM("cacheReadTokens"), 0)::INT  AS "totalCacheReadTokens",
+          COALESCE(SUM("estimatedCostUsd"), 0.0)    AS "totalEstimatedCostUsd",
+          COUNT(*)::INT                             AS "llmCallCount"
+        FROM "LLMCallLog"
+        WHERE "tenantId" = ${tenantId}
+          AND "jobId" = ${jobId}
+      `;
+      const row = rows[0];
+      if (!row || !row.llmCallCount) return;
+      await tx.platformJob.update({
+        where: { id: jobId },
+        data: {
+          totalPromptTokens: row.totalPromptTokens,
+          totalCompletionTokens: row.totalCompletionTokens,
+          totalCacheReadTokens: row.totalCacheReadTokens,
+          totalEstimatedCostUsd: Number(row.totalEstimatedCostUsd),
+          llmCallCount: row.llmCallCount
+        }
+      });
+    });
+  } catch (err) {
+    console.warn("[job-tokens] aggregation failed:", err);
+  }
+}
+async function processApiTestsJob(jobId, config) {
+  const { tenantId, projectId } = config;
+  const jobStartedAt = /* @__PURE__ */ new Date();
+  await withTenant(
+    tenantId,
+    (tx) => tx.platformJob.update({ where: { id: jobId }, data: { status: "RUNNING", startedAt: jobStartedAt } })
+  );
+  try {
+    const { generateApiTests, refreshCoverageMatrix, refreshTestCaseInventory } = await import("@taodigital/agents");
+    await updateJobProgress(tenantId, jobId, 20, "Loading API contracts and endpoints\u2026");
+    const result = await generateApiTests({ tenantId, projectId, apiEndpoints: config.apiEndpoints });
+    await updateJobProgress(tenantId, jobId, 90, `Generated ${result.cases?.length ?? 0} API test cases`);
+    refreshCoverageMatrix(tenantId, projectId).catch((e) => console.warn("[coverage-matrix]", e));
+    refreshTestCaseInventory(tenantId, projectId).catch((e) => console.warn("[tc-inventory]", e));
+    refreshTestCasesSkillFile(tenantId, projectId).catch(console.error);
+    enqueueJob("GENERATE_SCRIPT", { tenantId, projectId, source: "api_tests" }).catch(
+      (e) => console.warn("[GAP-007] GENERATE_SCRIPT enqueue failed (non-fatal):", e?.message ?? e)
+    );
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({
+        where: { id: jobId },
+        data: {
+          status: "DONE",
+          progress: 100,
+          finishedAt: /* @__PURE__ */ new Date(),
+          result: { cases: result.cases?.length ?? 0, suiteName: result.suiteName }
+        }
+      })
+    );
+    aggregateJobTokens(tenantId, jobId, projectId, jobStartedAt).catch(console.error);
+  } catch (err) {
+    await recordJobFailure(tenantId, jobId, err);
+  }
+}
+async function processSecurityTestsJob(jobId, config) {
+  const { tenantId, projectId } = config;
+  const jobStartedAt = /* @__PURE__ */ new Date();
+  await withTenant(
+    tenantId,
+    (tx) => tx.platformJob.update({ where: { id: jobId }, data: { status: "RUNNING", startedAt: jobStartedAt } })
+  );
+  try {
+    const { generateSecurityTests, refreshCoverageMatrix, refreshTestCaseInventory } = await import("@taodigital/agents");
+    await updateJobProgress(tenantId, jobId, 20, "Mapping OWASP attack surface\u2026");
+    const result = await generateSecurityTests({ tenantId, projectId, apiEndpoints: config.apiEndpoints });
+    await updateJobProgress(tenantId, jobId, 90, `Generated ${result.cases?.length ?? 0} security test cases`);
+    refreshCoverageMatrix(tenantId, projectId).catch((e) => console.warn("[coverage-matrix]", e));
+    refreshTestCaseInventory(tenantId, projectId).catch((e) => console.warn("[tc-inventory]", e));
+    refreshTestCasesSkillFile(tenantId, projectId).catch(console.error);
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({
+        where: { id: jobId },
+        data: {
+          status: "DONE",
+          progress: 100,
+          finishedAt: /* @__PURE__ */ new Date(),
+          result: { cases: result.cases?.length ?? 0, suiteName: result.suiteName }
+        }
+      })
+    );
+    aggregateJobTokens(tenantId, jobId, projectId, jobStartedAt).catch(console.error);
+  } catch (err) {
+    await recordJobFailure(tenantId, jobId, err);
+  }
+}
+async function processIntegrationTestsJob(jobId, config) {
+  const { tenantId, projectId } = config;
+  const jobStartedAt = /* @__PURE__ */ new Date();
+  await withTenant(
+    tenantId,
+    (tx) => tx.platformJob.update({ where: { id: jobId }, data: { status: "RUNNING", startedAt: jobStartedAt } })
+  );
+  try {
+    const { generateIntegrationTests, refreshCoverageMatrix, refreshTestCaseInventory } = await import("@taodigital/agents");
+    await updateJobProgress(tenantId, jobId, 20, "Analysing API contracts and data models\u2026");
+    const result = await generateIntegrationTests({ tenantId, projectId, apiEndpoints: config.apiEndpoints });
+    await updateJobProgress(tenantId, jobId, 90, `Generated ${result.cases?.length ?? 0} integration test cases`);
+    refreshCoverageMatrix(tenantId, projectId).catch((e) => console.warn("[coverage-matrix]", e));
+    refreshTestCaseInventory(tenantId, projectId).catch((e) => console.warn("[tc-inventory]", e));
+    refreshTestCasesSkillFile(tenantId, projectId).catch(console.error);
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({
+        where: { id: jobId },
+        data: {
+          status: "DONE",
+          progress: 100,
+          finishedAt: /* @__PURE__ */ new Date(),
+          result: { cases: result.cases?.length ?? 0, suiteName: result.suiteName }
+        }
+      })
+    );
+    aggregateJobTokens(tenantId, jobId, projectId, jobStartedAt).catch(console.error);
+  } catch (err) {
+    await recordJobFailure(tenantId, jobId, err);
+  }
+}
+async function processFigmaImportJob(jobId, config) {
+  const { tenantId, projectId, fileKey } = config;
+  await withTenant(
+    tenantId,
+    (tx) => tx.platformJob.update({ where: { id: jobId }, data: { status: "RUNNING", startedAt: /* @__PURE__ */ new Date() } })
+  );
+  try {
+    const oauthConn = await AppBrain.getOAuthConnection(tenantId, projectId, "FIGMA");
+    let creds;
+    const resolvedFileKey = fileKey ?? "";
+    if (!resolvedFileKey) throw new Error("No Figma file key. Paste the full Figma file URL as the App URL.");
+    if (oauthConn?.accessToken && oauthConn.status === "CONNECTED") {
+      creds = { accessToken: "", oauthToken: oauthConn.accessToken, fileKey: resolvedFileKey };
+    } else {
+      const connector = await withTenant(
+        tenantId,
+        (tx) => tx.connector.findFirst({ where: { projectId, kind: "FIGMA", tenantId } })
+      );
+      if (!connector) throw new Error("Figma connector not configured. Add your Figma token in Project Settings \u2192 Integrations.");
+      const cfg = connector.config;
+      const pat = cfg.accessToken_enc ? decrypt(cfg.accessToken_enc) : "";
+      if (!pat) throw new Error("Figma access token missing. Edit the Figma connector and add your Personal Access Token.");
+      creds = { accessToken: pat, fileKey: resolvedFileKey };
+    }
+    await updateJobProgress(tenantId, jobId, 5, "Listing frames from Figma file\u2026");
+    const frames = await figma.listScreens(creds, resolvedFileKey);
+    if (frames.length === 0) {
+      await withTenant(
+        tenantId,
+        (tx) => tx.platformJob.update({ where: { id: jobId }, data: { status: "DONE", progress: 100, result: { screensImported: 0 }, finishedAt: /* @__PURE__ */ new Date() } })
+      );
+      return;
+    }
+    await updateJobProgress(tenantId, jobId, 15, `Fetching images for ${frames.length} frames\u2026`);
+    const nodeIds = frames.map((f) => f.id);
+    const imageUrls = await figma.getScreenImages(creds, resolvedFileKey, nodeIds, 1);
+    const screenshotDir = path.join(platformConfig.screenshotDir, projectId);
+    await fs.mkdir(screenshotDir, { recursive: true });
+    const tenantStorageCfg = await getTenantStorageConfig(tenantId).catch(() => null);
+    let saved = 0;
+    for (const frame of frames) {
+      try {
+        const pct = Math.round(15 + saved / frames.length * 80);
+        await updateJobProgress(tenantId, jobId, pct, `Saving frame ${saved + 1}/${frames.length}: ${frame.name}`);
+        const screen = await AppBrain.saveScreen(tenantId, projectId, frame.name, `figma://file/${resolvedFileKey}/node/${frame.id}`);
+        const imgUrl = imageUrls[frame.id];
+        if (imgUrl) {
+          const imgRes = await fetch(imgUrl);
+          if (imgRes.ok) {
+            const buf = Buffer.from(await imgRes.arrayBuffer());
+            const filename = `${screen.id}-v1.png`;
+            const storagePath = path.join(screenshotDir, filename);
+            await fs.writeFile(storagePath, buf);
+            let cloudUrl;
+            if (tenantStorageCfg) {
+              try {
+                const key = buildArtifactKey(tenantId, projectId, "screenshots", filename, tenantStorageCfg.prefix);
+                cloudUrl = await uploadScreenshotToTenantStorage(tenantStorageCfg, storagePath, key) ?? void 0;
+              } catch (e) {
+                console.warn("[figma-import] cloud upload failed:", e);
+              }
+            }
+            const w = frame.boundingBox?.width ?? 1440;
+            const viewport = w <= 480 ? "MOBILE_PORTRAIT" : w <= 1024 ? "TABLET" : "DESKTOP";
+            await AppBrain.saveScreenshot(tenantId, projectId, screen.id, storagePath, 1, viewport, cloudUrl);
+          }
+        }
+        if (frame.node) {
+          const figmaElements = figma.extractElements(frame.node);
+          for (const el of figmaElements) {
+            const role = el.type === "COMPONENT" || el.type === "COMPONENT_SET" ? "COMPONENT" : el.type === "INSTANCE" ? "COMPONENT" : el.type === "TEXT" ? "TEXT" : el.type === "FRAME" || el.type === "GROUP" ? "REGION" : el.type;
+            const boundingRect = el.boundingBox ? { x: Math.round(el.boundingBox.x), y: Math.round(el.boundingBox.y), width: Math.round(el.boundingBox.width), height: Math.round(el.boundingBox.height) } : void 0;
+            await AppBrain.saveElement(
+              tenantId,
+              projectId,
+              screen.id,
+              el.name,
+              role,
+              void 0,
+              el.description ?? void 0,
+              void 0,
+              el.isInteractive,
+              boundingRect,
+              void 0,
+              void 0
+            );
+          }
+        }
+        saved++;
+      } catch (err) {
+        console.warn(`[figma-import] Failed to save frame:`, err);
+      }
+    }
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({
+        where: { id: jobId },
+        data: { status: "DONE", progress: 100, result: { screensImported: saved, totalFrames: frames.length }, finishedAt: /* @__PURE__ */ new Date() }
+      })
+    );
+    setImmediate(async () => {
+      try {
+        const projectMap = await AppBrain.getProjectMap(tenantId, projectId);
+        if (projectMap?.screens?.length) {
+          await generateTaxonomySkillFiles(tenantId, projectId, projectMap.screens);
+          await groupScreensWithAI(tenantId, projectId, projectMap.screens, jobId, /* @__PURE__ */ new Date());
+        }
+      } catch (err) {
+        console.error("[figma-import] post-import grouping failed:", err);
+      }
+    });
+  } catch (err) {
+    await recordJobFailure(tenantId, jobId, err);
+  }
+}
+async function processNativeCrawlJob(jobId, config) {
+  const { tenantId, projectId } = config;
+  const jobStartedAt = /* @__PURE__ */ new Date();
+  try {
+    const platform = config.nativePlatform;
+    if (!platform) throw new Error("Native crawl blocked: nativePlatform is required.");
+    const build = await withTenant(
+      tenantId,
+      (tx) => tx.nativeAppBuild.findFirst({
+        where: { tenantId, projectId, platform },
+        orderBy: { uploadedAt: "desc" }
+      })
+    );
+    if (!build) throw new Error(`Native crawl blocked: no ${platform} app build found for project.`);
+    if (build.fileFormat === "aab") {
+      throw new Error(
+        "AAB format cannot be installed directly by Appium. Convert to APK using bundletool first, then re-upload the APK."
+      );
+    }
+    const deviceFarm = config.deviceFarm ?? "local_emulator";
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({
+        where: { id: jobId },
+        data: {
+          deviceModel: config.deviceModel ?? null,
+          osVersion: config.osVersion ?? null,
+          deviceFarm
+        }
+      })
+    ).catch(() => {
+    });
+    const workspaceDeviceFarm = await AppBrain.getTenantDeviceFarmConfig(tenantId).catch(() => null);
+    if (deviceFarm === "browserstack" && (!workspaceDeviceFarm?.browserstackUsername || !workspaceDeviceFarm?.browserstackAccessKey)) {
+      throw new Error("Native crawl blocked: BrowserStack device farm is not configured for this workspace.");
+    }
+    if (deviceFarm === "aws_device_farm") {
+      throw new Error("Native crawl blocked: AWS Device Farm execution is not implemented yet. Use Local / Emulator or BrowserStack.");
+    }
+    await runNativeCrawl({
+      tenantId,
+      projectId,
+      jobId,
+      platform,
+      appS3Path: build.s3Path,
+      packageName: build.packageName ?? void 0,
+      deviceModel: config.deviceModel,
+      osVersion: config.osVersion,
+      deviceFarm,
+      appiumServerUrl: workspaceDeviceFarm?.appiumServerUrl,
+      browserstackUsername: workspaceDeviceFarm?.browserstackUsername,
+      browserstackAccessKey: workspaceDeviceFarm?.browserstackAccessKey,
+      awsAccessKeyId: workspaceDeviceFarm?.awsAccessKeyId,
+      awsSecretAccessKey: workspaceDeviceFarm?.awsSecretAccessKey,
+      awsRegion: workspaceDeviceFarm?.awsRegion,
+      awsDeviceFarmProjectArn: workspaceDeviceFarm?.awsDeviceFarmProjectArn
+    });
+    setImmediate(async () => {
+      try {
+        const projectMap = await AppBrain.getProjectMap(tenantId, projectId);
+        const screens = projectMap?.screens ?? [];
+        if (screens.length > 0) {
+          await generateTaxonomySkillFiles(tenantId, projectId, screens);
+          await groupScreensWithAI(tenantId, projectId, screens, jobId, jobStartedAt);
+          try {
+            await withTenant(tenantId, async (tx) => {
+              const staleTests = await tx.$queryRaw`
+                SELECT tc.id
+                FROM "TestCase" tc
+                JOIN "Screen" s ON tc."screenId" = s.id
+                WHERE tc."tenantId" = ${tenantId}
+                  AND s."projectId" = ${projectId}
+                  AND s."elementHashChangedAt" IS NOT NULL
+                  AND tc."createdAt" IS NOT NULL
+                  AND s."elementHashChangedAt" > tc."createdAt"
+                  AND tc.status != 'PENDING_REVIEW'
+                  AND tc.status != 'RETIRED'
+              `;
+              if (staleTests.length > 0) {
+                const ids = staleTests.map((t) => t.id);
+                await tx.testCase.updateMany({
+                  where: { id: { in: ids } },
+                  data: { status: "PENDING_REVIEW" }
+                });
+                logger.info({ count: staleTests.length, projectId }, "Auto-flagged stale test cases as PENDING_REVIEW");
+              }
+            });
+          } catch (staleErr) {
+            logger.warn({ err: staleErr }, "Failed to auto-flag stale tests");
+          }
+        }
+      } catch (e) {
+        logger.error({ err: e }, "post-native-crawl processing failed");
+      }
+    });
+  } catch (err) {
+    await recordJobFailure(tenantId, jobId, err);
+  }
+}
+async function processGenerateTestsFromReqsJob(jobId, config) {
+  const { tenantId, projectId, reqIds, suiteId, suiteName } = config;
+  try {
+    await updateJobProgress(tenantId, jobId, 5, "Loading requirements");
+    const { askTracked, deterministicSeed, getTaskAgentLLMConfig } = await import("@taodigital/agents");
+    const llmCfg = await getTaskAgentLLMConfig(tenantId, "testGeneration");
+    const all = await AppBrain.listRequirements(tenantId, projectId, {});
+    let reqs = reqIds?.length ? all.filter((r) => reqIds.includes(r.reqId)) : all.filter((r) => r.status === "unbuilt" || r.status === "pending");
+    if (reqs.length === 0) {
+      await updateJobProgress(tenantId, jobId, 100, "No pending requirements found");
+      await withTenant(
+        tenantId,
+        (tx) => tx.platformJob.update({ where: { id: jobId }, data: { status: "DONE", finishedAt: /* @__PURE__ */ new Date(), result: { created: 0, skipped: 0 } } })
+      );
+      return;
+    }
+    let resolvedSuiteId = suiteId;
+    if (!resolvedSuiteId) {
+      const name = suiteName?.trim() || "Requirements Tests";
+      const suite = await withTenant(tenantId, async (tx) => {
+        const existing = await tx.testSuite.findFirst({ where: { tenantId, projectId, name } });
+        if (existing) return existing;
+        return tx.testSuite.create({ data: { tenantId, projectId, name } });
+      });
+      resolvedSuiteId = suite.id;
+    }
+    const existingJob = await prismaAdmin.platformJob.findUnique({
+      where: { id: jobId },
+      select: { checkpoint: true }
+    }).catch(() => null);
+    const completedReqIds = new Set(existingJob?.checkpoint?.completedReqIds ?? []);
+    if (completedReqIds.size > 0) {
+      reqs = reqs.filter((r) => !completedReqIds.has(r.reqId));
+    }
+    await updateJobProgress(tenantId, jobId, 20, `Generating tests for ${reqs.length} requirements`);
+    const VALID_KINDS = /* @__PURE__ */ new Set(["POSITIVE", "NEGATIVE", "EDGE", "STATE_TRANSITION", "ACCESSIBILITY", "SECURITY", "INTEGRATION", "E2E", "API", "EXPLORATORY", "UAT", "PERFORMANCE", "COMPATIBILITY", "L10N", "USABILITY", "LOAD", "UNIT", "MUTATION", "AB_TEST", "ALPHA_BETA", "SYSTEM", "SMOKE", "REGRESSION", "SANITY"]);
+    const VALID_PRIORITIES = /* @__PURE__ */ new Set(["CRITICAL", "HIGH", "MEDIUM", "LOW"]);
+    const CHUNK_SIZE = 5;
+    let totalCreated = existingJob?.checkpoint?.createdCount ?? 0;
+    let totalSkipped = existingJob?.checkpoint?.skippedCount ?? 0;
+    const finishedReqIds = Array.from(completedReqIds);
+    for (let i = 0; i < reqs.length; i += CHUNK_SIZE) {
+      const chunk = reqs.slice(i, i + CHUNK_SIZE);
+      const reqBlock = chunk.map((r) => [
+        `## ${r.reqId}: ${r.title}`,
+        `Priority: ${r.priority} | Type: ${r.type}`,
+        r.acceptanceCriteria?.length ? `Acceptance Criteria:
+${r.acceptanceCriteria.map((c) => `- ${c}`).join("\n")}` : "",
+        r.businessRules?.length ? `Business Rules:
+${r.businessRules.map((b) => `- ${b}`).join("\n")}` : ""
+      ].filter(Boolean).join("\n")).join("\n\n");
+      const system = `You are ZeTa-AI's test case generator. Convert requirements into structured test cases.
+Return ONLY valid JSON: { "cases": [ { "title": string, "kind": string, "priority": string, "preconditions": string, "steps": [{"action": string, "data": string, "expected": string}], "expectedResult": string, "tags": string[], "reqRef": string } ] }
+Kind must be one of: POSITIVE, NEGATIVE, EDGE, SECURITY, ACCESSIBILITY, INTEGRATION, E2E, SMOKE, REGRESSION.
+Priority must be one of: CRITICAL, HIGH, MEDIUM, LOW.
+Generate 1-3 test cases per requirement (positive + negative + edge if applicable).
+Each test case must reference its reqRef (the requirement ID like REQ-001).`;
+      const user = `Generate test cases for these requirements:
+
+${reqBlock}`;
+      let parsed = { cases: [] };
+      try {
+        const reqSeed = deterministicSeed(`req-cases:${chunk.map((r) => r.reqId).sort().join("|").slice(0, 300)}`);
+        const { text, usage } = await askTracked(system, user, llmCfg, void 0, void 0, { temperature: 0, seed: reqSeed });
+        if (usage) recordLLMCall({ tenantId, projectId, jobId, agentType: "generate_tests_from_reqs", label: "test_case_generation", usage }).catch(() => {
+        });
+        const json = text.match(/\{[\s\S]*\}/)?.[0];
+        if (json) parsed = JSON.parse(json);
+      } catch (e) {
+        throw new Error("AI failed to generate test cases: " + (e.message ?? "unknown"));
+      }
+      const normalized = (parsed.cases ?? []).map((c) => ({
+        ref: c.reqRef ?? null,
+        traceTo: c.reqRef ?? null,
+        title: c.title || "Untitled",
+        kind: VALID_KINDS.has((c.kind ?? "").toUpperCase()) ? c.kind.toUpperCase() : "POSITIVE",
+        priority: VALID_PRIORITIES.has((c.priority ?? "").toUpperCase()) ? c.priority.toUpperCase() : "MEDIUM",
+        preconditions: c.preconditions ?? "",
+        steps: Array.isArray(c.steps) ? c.steps : [],
+        expectedResult: c.expectedResult ?? "",
+        tags: Array.isArray(c.tags) ? c.tags : []
+      }));
+      const { created, skipped } = await AppBrain.importTestCasesFromArtifact(
+        tenantId,
+        projectId,
+        resolvedSuiteId,
+        normalized,
+        { duplicateMode: "skip" }
+      );
+      totalCreated += created.length;
+      totalSkipped += skipped ?? 0;
+      const coveredReqIds = new Set(normalized.map((c) => c.ref).filter(Boolean));
+      await Promise.all(
+        chunk.filter((r) => coveredReqIds.has(r.reqId)).map((r) => AppBrain.updateRequirement(tenantId, projectId, r.reqId, { status: "covered" }).catch(() => {
+        }))
+      );
+      for (const r of chunk) finishedReqIds.push(r.reqId);
+      await prismaAdmin.platformJob.update({
+        where: { id: jobId },
+        data: {
+          checkpoint: { completedReqIds: finishedReqIds, createdCount: totalCreated, skippedCount: totalSkipped },
+          checkpointAt: /* @__PURE__ */ new Date()
+        }
+      }).catch(() => {
+      });
+      const progressPct = Math.round(20 + (i + chunk.length) / reqs.length * 75);
+      await updateJobProgress(tenantId, jobId, progressPct, `Processed ${finishedReqIds.length}/${reqs.length} requirements (${totalCreated} cases generated)`);
+    }
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({
+        where: { id: jobId },
+        data: { status: "DONE", finishedAt: /* @__PURE__ */ new Date(), result: { created: totalCreated, skipped: totalSkipped, suiteId: resolvedSuiteId }, progress: 100 }
+      })
+    );
+  } catch (e) {
+    const msg = e?.message ?? "Unknown error";
+    logger.error({ jobId, err: msg }, "processGenerateTestsFromReqsJob failed");
+    await recordJobFailure(tenantId, jobId, e);
+  }
+}
+async function processRunTestSuiteJob(jobId, config) {
+  const { tenantId, projectId, testRunId, suiteId, storageState, browser, shardIndex, totalShards } = config;
+  const runStart = Date.now();
+  await withTenant(
+    tenantId,
+    (tx) => tx.platformJob.update({ where: { id: jobId }, data: { status: "RUNNING", startedAt: /* @__PURE__ */ new Date() } })
+  );
+  try {
+    let testCases = await AppBrain.listTestCases(tenantId, projectId, {
+      status: "APPROVED",
+      ...suiteId ? { suiteId } : {}
+    });
+    if (typeof totalShards === "number" && totalShards > 1 && typeof shardIndex === "number") {
+      testCases = testCases.filter((_, i) => i % totalShards === shardIndex);
+    }
+    if (testCases.length === 0) {
+      await AppBrain.completeTestRun(tenantId, testRunId, { total: 0, passed: 0, failed: 0, skipped: 0, duration: 0 });
+      await withTenant(
+        tenantId,
+        (tx) => tx.platformJob.update({
+          where: { id: jobId },
+          data: { status: "DONE", progress: 100, finishedAt: /* @__PURE__ */ new Date(), result: { total: 0 } }
+        })
+      );
+      return;
+    }
+    const aiHealingEnabled = await isFeatureEnabled(tenantId, "AI_SELF_HEALING");
+    const SCREENSHOT_DIR = process.env.SCREENSHOT_DIR ?? "/tmp/zeta-screenshots";
+    const screenshotDir = config.screenshotDir || platformConfig.screenshotDir || SCREENSHOT_DIR;
+    const VALID_BROWSERS = ["chromium", "firefox", "webkit"];
+    const validBrowser = VALID_BROWSERS.includes(browser) ? browser : "chromium";
+    let passed = 0;
+    let failed = 0;
+    const runResults = [];
+    const existingJob = await prismaAdmin.platformJob.findUnique({
+      where: { id: jobId },
+      select: { checkpoint: true }
+    }).catch(() => null);
+    const completedCaseIds = new Set(existingJob?.checkpoint?.completedCaseIds ?? []);
+    if (completedCaseIds.size > 0) {
+      testCases = testCases.filter((tc) => !completedCaseIds.has(tc.id));
+      passed = existingJob?.checkpoint?.passed ?? 0;
+      failed = existingJob?.checkpoint?.failed ?? 0;
+    }
+    const allFinishedCaseIds = Array.from(completedCaseIds);
+    for (let i = 0; i < testCases.length; i += TEST_EXEC_CONCURRENCY) {
+      const batch = testCases.slice(i, i + TEST_EXEC_CONCURRENCY);
+      await Promise.all(batch.map(async (tc) => {
+        try {
+          const full = await AppBrain.getTestCaseForExecution(tenantId, tc.id);
+          const baseUrl = full?.screen?.project?.appUrl ?? "";
+          const execProjectId = full?.screen?.project?.id ?? projectId;
+          const dataRows = full?.dataSet?.rows ?? [];
+          const runs = dataRows.length > 0 ? dataRows : [null];
+          for (const row of runs) {
+            let tcForPlan = full ?? tc;
+            if (row !== null) {
+              const rawSteps = Array.isArray(tcForPlan.steps) ? tcForPlan.steps : [];
+              tcForPlan = {
+                ...tcForPlan,
+                steps: rawSteps.map((s) => interpolatePlaceholders(s, row.data)),
+                title: interpolatePlaceholders(tcForPlan.title ?? "", row.data),
+                preconditions: tcForPlan.preconditions ? interpolatePlaceholders(tcForPlan.preconditions, row.data) : tcForPlan.preconditions
+              };
+            }
+            const plan = await generateExecutionPlan(tenantId, tcForPlan, baseUrl);
+            const result = await executeTestPlan(plan, {
+              screenshotDir,
+              testRunId,
+              maxRuns: 1,
+              browser: validBrowser,
+              storageState,
+              healCtx: aiHealingEnabled ? { tenantId, projectId: execProjectId } : void 0
+            });
+            const status = result.status === "PASSED" ? "PASSED" : result.status === "ERROR" ? "ERROR" : "FAILED";
+            if (status === "PASSED") passed++;
+            else failed++;
+            runResults.push({ testCaseId: tc.id, status });
+            await AppBrain.saveTestResult(tenantId, {
+              runId: testRunId,
+              testCaseId: tc.id,
+              status,
+              duration: result.totalDuration,
+              ...result.rootCauseSummary ? { failureAnalysis: result.rootCauseSummary, failureAnalysisAt: /* @__PURE__ */ new Date() } : {},
+              ...row !== null ? { dataRowId: row.id, dataRowIndex: row.rowIndex } : {},
+              ...result.consoleLogs?.length || result.networkErrors?.length ? {
+                logs: {
+                  consoleLogs: result.consoleLogs ?? [],
+                  networkErrors: result.networkErrors ?? []
+                }
+              } : {}
+            });
+          }
+          await AppBrain.recordFlakinessOutcome(tenantId, tc.id).catch(() => {
+          });
+        } catch (err) {
+          failed++;
+          runResults.push({ testCaseId: tc.id, status: "ERROR" });
+          await AppBrain.saveTestResult(tenantId, {
+            runId: testRunId,
+            testCaseId: tc.id,
+            status: "ERROR",
+            error: String(err?.message ?? err).slice(0, 500)
+          }).catch(() => {
+          });
+        }
+      }));
+      for (const tc of batch) allFinishedCaseIds.push(tc.id);
+      await prismaAdmin.platformJob.update({
+        where: { id: jobId },
+        data: {
+          checkpoint: { completedCaseIds: allFinishedCaseIds, passed, failed },
+          checkpointAt: /* @__PURE__ */ new Date()
+        }
+      }).catch(() => {
+      });
+      await updateJobProgress(
+        tenantId,
+        jobId,
+        Math.round(Math.min(i + TEST_EXEC_CONCURRENCY, testCases.length) / testCases.length * 100),
+        `Ran ${Math.min(i + TEST_EXEC_CONCURRENCY, testCases.length)}/${testCases.length} test cases`
+      );
+    }
+    await AppBrain.completeTestRun(tenantId, testRunId, {
+      total: testCases.length,
+      passed,
+      failed,
+      skipped: 0,
+      duration: Date.now() - runStart
+    });
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({
+        where: { id: jobId },
+        data: { status: "DONE", progress: 100, finishedAt: /* @__PURE__ */ new Date(), result: { total: testCases.length, passed, failed } }
+      })
+    );
+    notifyRunCompletion(
+      tenantId,
+      projectId,
+      testRunId,
+      failed === 0 ? "COMPLETED" : "FAILED",
+      { passed, failed, total: testCases.length },
+      runResults
+    ).catch(console.error);
+    refreshTestExecutionHistorySkillFile(tenantId, projectId).catch(console.error);
+  } catch (err) {
+    const msg = String(err?.message ?? err).slice(0, 500);
+    logger.error({ jobId, testRunId, err: msg }, "processRunTestSuiteJob failed");
+    await AppBrain.failTestRun(tenantId, testRunId, msg).catch(() => {
+    });
+    await recordJobFailure(tenantId, jobId, err);
+  }
+}
+async function processGenerateSkillFilesJob(jobId, config) {
+  const { tenantId, projectId } = config;
+  await withTenant(
+    tenantId,
+    (tx) => tx.platformJob.update({ where: { id: jobId }, data: { status: "RUNNING", startedAt: /* @__PURE__ */ new Date() } })
+  );
+  try {
+    await updateJobProgress(tenantId, jobId, 10, "Loading project data\u2026");
+    const projectMap = await AppBrain.getProjectMap(tenantId, projectId);
+    if (!projectMap) throw new Error("Project not found.");
+    const screens = projectMap.screens ?? [];
+    const lastCrawl = await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.findFirst({
+        where: { projectId, type: "CRAWL", status: "DONE" },
+        orderBy: { finishedAt: "desc" },
+        select: { result: true }
+      })
+    );
+    const lastResult = lastCrawl?.result ?? {};
+    await updateJobProgress(tenantId, jobId, 25, `Generating ${screens.length} app intelligence skill files\u2026`);
+    await generateTaxonomySkillFiles(tenantId, projectId, screens, lastResult.apiEndpoints, lastResult.performanceMetrics);
+    await updateJobProgress(tenantId, jobId, 85, "Refreshing testing intelligence skill files\u2026");
+    await Promise.allSettled([
+      refreshTestCasesSkillFile(tenantId, projectId),
+      refreshTestDataSkillFile(tenantId, projectId),
+      refreshTestScriptSkillFile(tenantId, projectId),
+      refreshRequirementsCoverageSkillFile(tenantId, projectId),
+      refreshTestExecutionHistorySkillFile(tenantId, projectId),
+      refreshVisualRegressionHistorySkillFile(tenantId, projectId),
+      refreshLocatorStrategyWithHealingData(tenantId, projectId),
+      refreshFieldCatalogSkillFile(tenantId, projectId)
+    ]);
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({ where: { id: jobId }, data: { status: "DONE", progress: 100, finishedAt: /* @__PURE__ */ new Date() } })
+    );
+  } catch (err) {
+    await recordJobFailure(tenantId, jobId, err);
+  }
+}
+async function processDataRetentionPurge() {
+  logger.info("[data-retention] starting purge run");
+  const llmCutoff = new Date(Date.now() - 90 * 24 * 60 * 60 * 1e3);
+  const llmResult = await prismaAdmin.lLMCallLog.deleteMany({
+    where: { calledAt: { lt: llmCutoff } }
+  });
+  logger.info({ deleted: llmResult.count }, "[data-retention] LLMCallLog purged");
+  const tenants = await prismaAdmin.tenant.findMany({ select: { id: true } });
+  let auditTotal = 0;
+  for (const { id: tenantId } of tenants) {
+    const setting = await prismaAdmin.tenantSetting.findFirst({
+      where: { tenantId },
+      orderBy: { dataRetentionDays: "asc" },
+      select: { dataRetentionDays: true }
+    });
+    const retentionDays = setting?.dataRetentionDays ?? (parseInt(process.env.DEFAULT_DATA_RETENTION_DAYS ?? "") || 365);
+    const cutoff = new Date(Date.now() - retentionDays * 24 * 60 * 60 * 1e3);
+    const result = await prismaAdmin.auditLog.deleteMany({
+      where: { tenantId, createdAt: { lt: cutoff } }
+    });
+    auditTotal += result.count;
+  }
+  logger.info({ deleted: auditTotal, tenants: tenants.length }, "[data-retention] AuditLog purged");
+  const SESSION_RETENTION_DAYS = 365;
+  const sessionCutoff = new Date(Date.now() - SESSION_RETENTION_DAYS * 24 * 60 * 6e4);
+  const sessionResult = await prismaAdmin.authSession.deleteMany({
+    where: {
+      createdAt: { lt: sessionCutoff },
+      revokedAt: { not: null }
+    }
+  });
+  logger.info({ deleted: sessionResult.count }, "[data-retention] AuthSession purged");
+  const ninetyDaysAgo = new Date(Date.now() - 90 * 24 * 60 * 60 * 1e3);
+  const deletedJobs = await prismaAdmin.platformJob.deleteMany({
+    where: {
+      status: { in: ["DONE", "FAILED"] },
+      dlq: false,
+      inline: false,
+      finishedAt: { lt: ninetyDaysAgo }
+    }
+  });
+  if (deletedJobs.count > 0) {
+    logger.info({ count: deletedJobs.count }, "[data-retention] deleted old completed jobs");
+  }
+}
+async function processDiscoverJob(jobId, config, opts) {
+  const { tenantId, projectId } = config;
+  const controller = new AbortController();
+  runningControllers.set(jobId, controller);
+  const heartbeatTimer = setInterval(() => {
+    void heartbeatJob(tenantId, jobId);
+  }, JOB_HEARTBEAT_INTERVAL_MS);
+  const allUrls = /* @__PURE__ */ new Set();
+  let lastPartialFlush = 0;
+  let lastFlushedPct = 0;
+  const flushPartialUrls = async (pct, step) => {
+    const now = Date.now();
+    if (now - lastPartialFlush < 5e3 && allUrls.size < 5) return;
+    const monotonic = Math.max(pct, lastFlushedPct);
+    lastFlushedPct = monotonic;
+    lastPartialFlush = now;
+    try {
+      await withTenant(
+        tenantId,
+        (tx) => tx.platformJob.update({
+          where: { id: jobId },
+          data: { progress: monotonic, result: { step, partialUrls: Array.from(allUrls) }, heartbeatAt: /* @__PURE__ */ new Date() }
+        })
+      );
+    } catch {
+    }
+    await opts?.onProgress?.(monotonic);
+  };
+  const onProgress = async (pct, step) => {
+    await updateJobProgress(tenantId, jobId, pct, step);
+    await opts?.onProgress?.(pct);
+  };
+  try {
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({ where: { id: jobId }, data: { status: "RUNNING", startedAt: /* @__PURE__ */ new Date() } })
+    );
+    const crawlCfg = await AppBrain.getCrawlConfig(tenantId, projectId).catch(() => null) ?? {};
+    const appUrl = config.appUrl ?? crawlCfg.appUrl;
+    if (!appUrl) throw new Error("No app URL configured. Save the crawl settings first.");
+    const { getSystemConfig } = await import("@taodigital/core");
+    const crawlTuning = await getSystemConfig("crawl_tuning");
+    const maxDiscoverUrls = config.maxDiscoverUrls ?? parseInt(String(crawlTuning?.maxDiscoverUrls ?? "2000"), 10);
+    const proxyUrl = config.proxyUrl ?? crawlCfg.proxyUrl;
+    const screenshotDir = os.tmpdir();
+    const discoverStorageConfig = await getTenantStorageConfig(tenantId).catch(() => null);
+    await onProgress(3, "Seeding from sitemap/robots.txt\u2026");
+    const sitemapResult = await discoverProjectUrls(appUrl, {
+      sitemapUrl: config.sitemapUrl ?? crawlCfg.sitemapUrl,
+      proxyUrl
+    }).catch(() => ({ candidates: [], sitemapFound: false }));
+    const sitemapUrls = sitemapResult.candidates.map((c) => c.url);
+    for (const u of sitemapUrls) allUrls.add(u);
+    logger.info({ count: sitemapUrls.length, sitemapFound: sitemapResult.sitemapFound }, "[discover] Phase 1 sitemap done");
+    await onProgress(8, `Unauthenticated spider from ${appUrl}\u2026`);
+    const unauthResult = await crawlProject({
+      tenantId,
+      projectId,
+      appUrl,
+      discoveryMode: true,
+      startUrls: sitemapUrls.length > 0 ? sitemapUrls : void 0,
+      screenshotDir,
+      maxScreens: maxDiscoverUrls,
+      proxyUrl,
+      useFirefox: crawlCfg.useFirefox,
+      storageConfig: discoverStorageConfig,
+      abortSignal: controller.signal,
+      jobId,
+      onUrlsDiscovered: async (urls) => {
+        for (const u of urls) allUrls.add(u);
+        const pct = 8 + Math.round(allUrls.size / Math.max(1, maxDiscoverUrls) * 42);
+        await flushPartialUrls(Math.min(pct, 49), `Discovered ${allUrls.size} URLs\u2026`);
+      }
+    }, async (pct, step) => {
+      await flushPartialUrls(8 + Math.round(pct * 0.42), `Unauthenticated: ${step}`);
+    }).catch((err) => {
+      if (err?.message === "CRAWL_ABORTED") throw err;
+      logger.warn({ err: err?.message }, "[discover] Phase 2 unauthenticated spider failed \u2014 continuing with partial results");
+      return { discoveredUrls: [] };
+    });
+    for (const u of unauthResult.discoveredUrls ?? []) allUrls.add(u);
+    logger.info({ count: allUrls.size }, "[discover] Phase 2 unauth spider done");
+    let resolvedSso = {};
+    if (crawlCfg.ssoProviderId) {
+      const ssoProviders = await AppBrain.getWorkspaceSsoProviders(tenantId).catch(() => []);
+      const ssoProvider = ssoProviders.find((p) => p.id === crawlCfg.ssoProviderId);
+      if (ssoProvider) {
+        resolvedSso = {
+          ssoProvider: ssoProvider.provider,
+          ssoDomain: ssoProvider.domain,
+          ssoClientId: ssoProvider.clientId,
+          ssoClientSecret: ssoProvider.clientSecret,
+          ssoScope: ssoProvider.scope
+        };
+      }
+    }
+    const hasCreds = !!(crawlCfg.username || crawlCfg.storageState || crawlCfg.authToken || crawlCfg.chromeProfilePath || crawlCfg.httpBasicUsername && crawlCfg.httpBasicPassword);
+    if (hasCreds && !controller.signal.aborted) {
+      await onProgress(52, "Authenticated spider\u2026");
+      const runtimeCreds = crawlCfg.username ? {
+        username: crawlCfg.username,
+        password: crawlCfg.password ?? "",
+        ...crawlCfg.totpSecret ? { getOneTimeCode: async () => generateTOTP(crawlCfg.totpSecret) } : {}
+      } : void 0;
+      const PHASE3_TIMEOUT_MS = 20 * 6e4;
+      const authResult = await Promise.race([
+        crawlProject({
+          tenantId,
+          projectId,
+          appUrl,
+          discoveryMode: true,
+          credentials: runtimeCreds,
+          storageState: crawlCfg.storageState,
+          httpBasicUsername: crawlCfg.httpBasicUsername,
+          httpBasicPassword: crawlCfg.httpBasicPassword,
+          authToken: crawlCfg.authToken,
+          authTokenHeader: crawlCfg.authTokenHeader,
+          authTokenPrefix: crawlCfg.authTokenPrefix,
+          startUrls: crawlCfg.postLoginUrl ? [crawlCfg.postLoginUrl, ...sitemapUrls.length > 0 ? sitemapUrls : []] : sitemapUrls.length > 0 ? sitemapUrls : void 0,
+          screenshotDir,
+          maxScreens: maxDiscoverUrls,
+          proxyUrl,
+          chromeProfilePath: crawlCfg.chromeProfilePath,
+          useFirefox: crawlCfg.useFirefox,
+          storageConfig: discoverStorageConfig,
+          captchaSolverApiKey: crawlCfg.captchaSolverApiKey,
+          captchaSolverProvider: crawlCfg.captchaSolverProvider,
+          mailslurpApiKey: crawlCfg.mailslurpApiKey,
+          mailslurpInboxId: crawlCfg.mailslurpInboxId,
+          loginInstructions: crawlCfg.loginInstructions,
+          ...resolvedSso,
+          abortSignal: controller.signal,
+          jobId,
+          onUrlsDiscovered: async (urls) => {
+            for (const u of urls) allUrls.add(u);
+            const pct = 52 + Math.round(allUrls.size / Math.max(1, maxDiscoverUrls) * 38);
+            await flushPartialUrls(Math.min(pct, 89), `Discovered ${allUrls.size} URLs (authenticated)\u2026`);
+          }
+        }, async (pct, step) => {
+          await flushPartialUrls(52 + Math.round(pct * 0.38), `Authenticated: ${step}`);
+        }),
+        new Promise((_, rej) => setTimeout(() => rej(new Error("AUTH_PHASE_TIMEOUT")), PHASE3_TIMEOUT_MS))
+      ]).catch((err) => {
+        if (err?.message === "CRAWL_ABORTED") throw err;
+        const reason = err?.message === "AUTH_PHASE_TIMEOUT" ? "Authenticated spider timed out after 20 minutes" : err?.message;
+        logger.warn({ reason }, "[discover] Phase 3 authenticated spider failed \u2014 using unauthenticated results");
+        return { discoveredUrls: [] };
+      });
+      for (const u of authResult.discoveredUrls ?? []) {
+        allUrls.add(u);
+      }
+      logger.info({ count: allUrls.size }, "[discover] Phase 3 auth spider done");
+    }
+    const discoveredUrls = Array.from(allUrls).filter((u) => u.startsWith("http"));
+    const existingCfg = await AppBrain.getCrawlConfig(tenantId, projectId).catch(() => ({}));
+    await AppBrain.saveCrawlConfig(tenantId, projectId, {
+      ...existingCfg,
+      discoveredUrls,
+      discoveredAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await onProgress(100, `Done \u2014 ${discoveredUrls.length} URLs discovered`);
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({
+        where: { id: jobId },
+        data: {
+          status: "DONE",
+          result: {
+            discoveredUrls,
+            count: discoveredUrls.length,
+            sitemapFound: sitemapResult.sitemapFound
+          },
+          progress: 100,
+          finishedAt: /* @__PURE__ */ new Date()
+        }
+      })
+    );
+    notifyAdmins(tenantId, {
+      type: "discovery.done",
+      title: "URL Discovery completed",
+      body: `Found ${discoveredUrls.length} URLs for the project.`,
+      metadata: { projectId, jobId }
+    }).catch(console.error);
+  } catch (err) {
+    logger.error({ err: err?.message, jobId }, "[discover] Job failed");
+    await recordJobFailure(tenantId, jobId, err);
+  } finally {
+    clearInterval(heartbeatTimer);
+    runningControllers.delete(jobId);
+  }
+}
+async function processMonitorJob(jobId, config, opts) {
+  const { tenantId, projectId } = config;
+  const controller = new AbortController();
+  runningControllers.set(jobId, controller);
+  try {
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({ where: { id: jobId }, data: { status: "RUNNING", startedAt: /* @__PURE__ */ new Date() } })
+    );
+    const proj = await withTenant(
+      tenantId,
+      (tx) => tx.project.findUnique({ where: { id: projectId }, select: { crawlConfig: true } })
+    );
+    const crawlCfg = proj?.crawlConfig ?? {};
+    const monitorUrls = config.monitorUrls ?? crawlCfg.monitorUrls ?? [];
+    if (monitorUrls.length === 0) {
+      throw new Error("No monitor URLs configured. Add monitorUrls to crawl config or job config.");
+    }
+    await updateJobProgress(tenantId, jobId, 10, `Monitoring ${monitorUrls.length} URL(s)...`);
+    const storedBaselines = crawlCfg.monitorBaselines ?? {};
+    const projectScreens = await withTenant(
+      tenantId,
+      (tx) => tx.screen.findMany({ where: { projectId }, select: { url: true, elementHash: true } })
+    ).catch(() => []);
+    const screenHashMap = {};
+    for (const s of projectScreens) {
+      if (s.url && s.elementHash) screenHashMap[s.url] = s.elementHash;
+    }
+    const results = [];
+    const newBaselines = { ...storedBaselines };
+    for (let i = 0; i < monitorUrls.length; i++) {
+      if (controller.signal.aborted) break;
+      const url = monitorUrls[i];
+      const pct = 10 + Math.floor(i / monitorUrls.length * 80);
+      await updateJobProgress(tenantId, jobId, pct, `Checking ${url}...`);
+      opts?.onProgress?.(pct);
+      try {
+        const crawlResult = await httpCrawl({ appUrl: url, maxScreens: 1, respectRobotsTxt: false, timeoutMs: parseInt(process.env.CRAWL_TIMEOUT_MS ?? "20000", 10) });
+        const screen = crawlResult.screens[0];
+        if (!screen) {
+          results.push({ url, changed: false, reason: "fetch_empty", currentHash: "", previousHash: null });
+          continue;
+        }
+        const currentHash = hashContent(normalizeText(screen.markdown));
+        const previousHash = storedBaselines[url] ?? screenHashMap[url] ?? null;
+        newBaselines[url] = currentHash;
+        if (!previousHash) {
+          results.push({ url, changed: false, reason: "new_baseline", currentHash, previousHash: null });
+        } else if (previousHash === currentHash) {
+          results.push({ url, changed: false, reason: "unchanged", currentHash, previousHash });
+        } else {
+          results.push({ url, changed: true, reason: "content_changed", currentHash, previousHash });
+        }
+      } catch (fetchErr) {
+        results.push({ url, changed: false, reason: `error:${fetchErr?.message ?? String(fetchErr)}`, currentHash: "", previousHash: null });
+      }
+    }
+    await withTenant(
+      tenantId,
+      (tx) => tx.project.update({
+        where: { id: projectId },
+        data: { crawlConfig: { ...crawlCfg, monitorBaselines: newBaselines } }
+      })
+    ).catch((e) => logger.warn({ err: e }, "[monitor] baseline persist failed"));
+    const changedUrls = results.filter((r) => r.changed);
+    if (changedUrls.length > 0) {
+      dispatchWebhook(tenantId, projectId, "content.changed", {
+        jobId,
+        changedUrls: changedUrls.map((r) => ({ url: r.url, previousHash: r.previousHash, currentHash: r.currentHash })),
+        totalChecked: results.length,
+        changedCount: changedUrls.length
+      }).catch(console.error);
+    }
+    await updateJobProgress(tenantId, jobId, 100, "Monitor check complete");
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({
+        where: { id: jobId },
+        data: {
+          status: "DONE",
+          progress: 100,
+          finishedAt: /* @__PURE__ */ new Date(),
+          result: { results, changedCount: changedUrls.length, totalChecked: results.length }
+        }
+      })
+    );
+  } catch (err) {
+    await recordJobFailure(tenantId, jobId, err);
+  } finally {
+    runningControllers.delete(jobId);
+  }
+}
+async function processImportTestsJob(jobId, config) {
+  const { tenantId, projectId, artifactId, autoLabel, sourcePlatform } = config;
+  const jobStart = /* @__PURE__ */ new Date();
+  let suiteId = config.suiteId ?? "new";
+  await updateJobProgress(tenantId, jobId, 5, "Loading artifact");
+  const artifact = await withTenant(
+    tenantId,
+    (tx) => tx.projectArtifact.findUnique({ where: { id: artifactId } })
+  );
+  if (!artifact || artifact.tenantId !== tenantId) {
+    throw new Error(`Artifact ${artifactId} not found`);
+  }
+  const content = artifact.content ?? "";
+  const filename = artifact.originalName ?? artifact.name ?? "";
+  const kind = artifact.kind ?? "";
+  function detectFormat(fn, k, c) {
+    if (fn.endsWith(".feature")) return "GHERKIN";
+    if (fn.match(/\.(xlsx|xls|csv)$/i) || k === "SPREADSHEET") return "EXCEL";
+    if (fn.endsWith(".txt") && c && c.split("\n").some((l) => l.trim().startsWith("|"))) return "EXCEL";
+    return "AI_EXTRACT";
+  }
+  const format = detectFormat(filename, kind, content);
+  await updateJobProgress(tenantId, jobId, 15, `Parsing ${filename}`);
+  const { parseTestCases, labelTestCasesBatch } = await import("@taodigital/agents");
+  let res = await parseTestCases(content, format, tenantId, artifact.columnMapping ?? void 0, void 0, void 0, sourcePlatform);
+  if (res.cases.length === 0 && format !== "AI_EXTRACT") {
+    await updateJobProgress(tenantId, jobId, 25, "Retrying with AI extraction");
+    try {
+      res = await parseTestCases(content, "AI_EXTRACT", tenantId, void 0, void 0, void 0, sourcePlatform);
+    } catch {
+    }
+  }
+  const parsedCases = res.cases;
+  if (parsedCases.length === 0) {
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({
+        where: { id: jobId },
+        data: { status: "DONE", progress: 100, finishedAt: /* @__PURE__ */ new Date(), result: { imported: 0, skipped: 0, labeled: 0 } }
+      })
+    );
+    return;
+  }
+  await updateJobProgress(tenantId, jobId, 35, `Parsed ${parsedCases.length} cases \u2014 creating suite`);
+  if (!suiteId || suiteId === "new") {
+    const suiteName = filename.replace(/\.[^/.]+$/, "") || "Imported Tests";
+    const suite = await withTenant(
+      tenantId,
+      (tx) => tx.testSuite.create({
+        data: { tenantId, projectId, name: suiteName }
+      })
+    );
+    suiteId = suite.id;
+  }
+  await updateJobProgress(tenantId, jobId, 50, `Importing ${parsedCases.length} cases`);
+  const { created, skipped } = await AppBrain.importTestCasesFromArtifact(
+    tenantId,
+    projectId,
+    suiteId,
+    parsedCases,
+    { duplicateMode: "skip", artifactId }
+  );
+  let labeled = 0;
+  if (autoLabel && created.length > 0) {
+    await updateJobProgress(tenantId, jobId, 75, `AI labeling ${created.length} cases`);
+    try {
+      const labelInput = created.map((c) => ({
+        id: c.id,
+        title: c.title,
+        description: c.description ?? "",
+        stepsText: (Array.isArray(c.steps) ? c.steps.join(" ") : String(c.steps ?? "")).slice(0, 200)
+      }));
+      const labelResults = await labelTestCasesBatch(labelInput, tenantId);
+      await Promise.all(
+        labelResults.map(
+          (lr) => withTenant(
+            tenantId,
+            (tx) => tx.testCase.update({
+              where: { id: lr.id },
+              data: {
+                priority: lr.priority ?? void 0,
+                kind: lr.kind ?? void 0,
+                tags: lr.tags ?? void 0,
+                status: lr.needsReview ? "PENDING_REVIEW" : void 0
+              }
+            })
+          ).catch(() => {
+          })
+          // non-fatal per-case
+        )
+      );
+      labeled = labelResults.length;
+    } catch {
+    }
+  }
+  const casesNeedingData = created.filter((c) => {
+    const inline = c.testDataInline;
+    return inline && typeof inline === "object" && Object.keys(inline).length > 0;
+  });
+  if (casesNeedingData.length > 0) {
+    const cap = Math.min(casesNeedingData.length, 20);
+    await updateJobProgress(tenantId, jobId, 90, `Generating test data for ${cap} cases`);
+    const { generateTestData, refreshTestDataSkillFile: refreshTestDataSkillFile2 } = await import("@taodigital/agents");
+    for (let i = 0; i < cap; i++) {
+      const c = casesNeedingData[i];
+      await generateTestData({ tenantId, projectId, testCaseId: c.id, jobId }).catch((e) => {
+        logger.warn({ err: e?.message, testCaseId: c.id }, "[import] test data generation failed");
+      });
+    }
+    refreshTestDataSkillFile2(tenantId, projectId).catch(console.error);
+  }
+  if (created.length > 0) {
+    refreshTestCasesSkillFile(tenantId, projectId).catch(console.error);
+  }
+  await updateJobProgress(tenantId, jobId, 98, `Done \u2014 ${created.length} imported`);
+  await withTenant(
+    tenantId,
+    (tx) => tx.platformJob.update({
+      where: { id: jobId },
+      data: {
+        status: "DONE",
+        progress: 100,
+        finishedAt: /* @__PURE__ */ new Date(),
+        result: {
+          imported: created.length,
+          skipped: skipped ?? 0,
+          labeled,
+          suiteId,
+          artifactId,
+          artifactName: filename
+        }
+      }
+    })
+  );
+  aggregateJobTokens(tenantId, jobId, projectId, jobStart).catch(console.error);
+}
+async function processGenerateScreenTestsJob(jobId, config) {
+  const { tenantId, projectId, screenId, repoConnectionId, triggerAlignedScripts } = config;
+  const jobStartedAt = /* @__PURE__ */ new Date();
+  try {
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({ where: { id: jobId }, data: { status: "RUNNING", startedAt: jobStartedAt } })
+    );
+    const { DualContextOrchestrator } = await import("@taodigital/agents");
+    await updateJobProgress(tenantId, jobId, 10, "Generating test cases for screen");
+    const crawlCfg = await AppBrain.getCrawlConfig(tenantId, projectId).catch(() => null);
+    const deviceProfiles = crawlCfg?.deviceProfiles ?? ["DESKTOP"];
+    const existingAiCases = await withTenant(
+      tenantId,
+      (tx) => tx.testCase.count({ where: { tenantId, screenId, source: "AI_GENERATED" } })
+    );
+    const generationMode = existingAiCases > 0 ? "replace" : void 0;
+    for (const viewport of deviceProfiles) {
+      await DualContextOrchestrator.execute({ tenantId, projectId, targetScreenId: screenId, jobId, viewport, ...generationMode ? { mode: generationMode } : {} });
+    }
+    await updateJobProgress(tenantId, jobId, 80, "Test cases generated");
+    if (triggerAlignedScripts && repoConnectionId) {
+      const conn = await withTenant(
+        tenantId,
+        (tx) => tx.gitHubRepoConnection.findFirst({ where: { id: repoConnectionId, tenantId } })
+      );
+      if (conn?.styleProfile) {
+        const { generateScriptAligned, mapWithConcurrency, SCRIPT_GEN_CONCURRENCY } = await import("@taodigital/agents");
+        const cases = await withTenant(
+          tenantId,
+          (tx) => tx.testCase.findMany({ where: { tenantId, projectId, screenId, status: "APPROVED" }, select: { id: true }, take: 50 })
+        );
+        await mapWithConcurrency(
+          cases,
+          SCRIPT_GEN_CONCURRENCY,
+          (tc) => generateScriptAligned({
+            tenantId,
+            projectId,
+            testCaseId: tc.id,
+            styleProfile: conn.styleProfile,
+            pageObjectInventory: conn.pageObjectInventory ?? void 0
+          }).catch(() => {
+          })
+        );
+      }
+    }
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({ where: { id: jobId }, data: { status: "DONE", progress: 100, finishedAt: /* @__PURE__ */ new Date() } })
+    );
+    aggregateJobTokens(tenantId, jobId, projectId, jobStartedAt).catch(console.error);
+  } catch (err) {
+    const msg = err?.message ?? String(err);
+    logger.error({ jobId, screenId, err: msg }, "processGenerateScreenTestsJob failed");
+    await recordJobFailure(tenantId, jobId, err);
+  }
+}
+function captureStepText(step) {
+  if (typeof step === "string") return step;
+  if (!step || typeof step !== "object") return "";
+  const obj = step;
+  return [obj.action, obj.text, obj.label, obj.data, obj.expected].filter((v) => typeof v === "string" && v.trim().length > 0).join(" -> ");
+}
+function firstQuoted(text) {
+  return (text.match(/"([^"]+)"/)?.[1] ?? text.match(/'([^']+)'/)?.[1])?.trim();
+}
+function fallbackExecutionPlan(rawSteps) {
+  const plan = [];
+  for (const raw of rawSteps) {
+    const text = captureStepText(raw).trim();
+    if (!text) continue;
+    const stepNumber = plan.length + 1;
+    const url = text.match(/https?:\/\/[^\s"']+/)?.[0];
+    if (/^navigate\b|^go to\b|^open\b/i.test(text) && url) {
+      plan.push({ stepNumber, description: text, action: "navigate", url });
+      continue;
+    }
+    const urlContains = text.match(/verify url contains:\s*["']?([^"']+)["']?/i);
+    if (urlContains) {
+      plan.push({ stepNumber, description: text, action: "assert_url", value: urlContains[1].trim() });
+      continue;
+    }
+    const inputMatch = text.match(/(?:enter|type|fill)\s+["']([^"']+)["']\s+(?:in|into)\s+(.+?)(?:\s+field|\s+input|\s+box|\s+area)?(?:\s*→.*)?$/i);
+    if (inputMatch) {
+      const selector = inputMatch[2].replace(/^(the\s+)?/i, "").replace(/\s+(field|input|box|area)$/i, "").trim();
+      plan.push({ stepNumber, description: text, action: "fill", selectorStrategy: "label", selector, value: inputMatch[1].trim() });
+      continue;
+    }
+    const quoted = firstQuoted(text);
+    if (/^(click|tap|navigate menu|check|select)\b/i.test(text) && quoted) {
+      plan.push({ stepNumber, description: text, action: "click", selectorStrategy: "text", selector: quoted });
+      continue;
+    }
+    if (/^(verify|assert|expect)\b/i.test(text) && quoted) {
+      plan.push({ stepNumber, description: text, action: "assert_visible", selectorStrategy: "text", selector: quoted });
+      continue;
+    }
+    if (/execute script/i.test(text)) {
+      const script = text.split(":").slice(1).join(":").replace(/\s*→.*$/, "").trim();
+      if (script) plan.push({ stepNumber, description: text, action: "script", value: script });
+    }
+  }
+  return plan;
+}
+function screenNameFromUrl(url, fallback) {
+  try {
+    const u = new URL(url);
+    return u.pathname.replace(/\/+$/, "").split("/").filter(Boolean).pop() || u.hostname || fallback;
+  } catch {
+    return fallback;
+  }
+}
+async function processCaptureStepsJob(jobId, config) {
+  const { tenantId, projectId, testCaseId } = config;
+  const screenshotDir = config.screenshotDir || platformConfig.screenshotDir || process.env.SCREENSHOT_DIR || "/tmp/zeta-screenshots";
+  await fs.mkdir(screenshotDir, { recursive: true });
+  await withTenant(
+    tenantId,
+    (tx) => tx.platformJob.update({ where: { id: jobId }, data: { status: "RUNNING", startedAt: /* @__PURE__ */ new Date(), progress: 2 } })
+  );
+  let browser;
+  try {
+    await updateJobProgress(tenantId, jobId, 5, "Loading test case");
+    const [tc, crawlCfg, tenantStorageCfg] = await Promise.all([
+      AppBrain.getTestCaseForExecution(tenantId, testCaseId),
+      AppBrain.getCrawlConfig(tenantId, projectId).catch(() => null),
+      getTenantStorageConfig(tenantId).catch(() => null)
+    ]);
+    if (!tc) throw new Error("Test case not found");
+    const rawSteps = Array.isArray(tc.steps) ? tc.steps : [];
+    if (rawSteps.length === 0) throw new Error("Test case has no steps to capture");
+    const _tdi = tc.testDataInline ?? {};
+    const _tdiStartUrl = typeof _tdi["startUrl"] === "string" && _tdi["startUrl"].startsWith("http") ? _tdi["startUrl"] : "";
+    const _recordedUrls = Array.isArray(_tdi["recordedUrls"]) ? _tdi["recordedUrls"].map(String) : [];
+    const _recordedStartUrl = _recordedUrls.find((u) => u.startsWith("http")) ?? "";
+    const baseUrl = config.baseUrl || _tdiStartUrl || _recordedStartUrl || tc?.screen?.project?.appUrl || crawlCfg?.appUrl || "";
+    const _envTokenMap = {};
+    for (const [k, v] of Object.entries(_tdi)) {
+      if (typeof v === "string" && v.startsWith("http")) _envTokenMap[k] = v;
+    }
+    if (_recordedStartUrl && !_envTokenMap["startUrl"]) _envTokenMap["startUrl"] = _recordedStartUrl;
+    const resolveStepText = (text) => text.replace(/\{\{\s*fze\.env\.([A-Za-z_][A-Za-z0-9_]*)\s*\}\}/g, (_m, k) => _envTokenMap[k] ?? `[${k}]`).replace(/\[env:([A-Za-z_][A-Za-z0-9_]*)\]/g, (_m, k) => _envTokenMap[k] ?? `[${k}]`);
+    const stepTexts = rawSteps.map(captureStepText).filter(Boolean).map(resolveStepText);
+    if (stepTexts.length === 0) throw new Error("Test case has no steps to capture");
+    let plan = await generateExecutionPlan(tenantId, { ...tc, steps: stepTexts }, baseUrl).catch(() => []);
+    plan = Array.isArray(plan) ? plan.filter(Boolean).map((step, idx) => ({ ...step, stepNumber: idx + 1 })) : [];
+    if (plan.length === 0) plan = fallbackExecutionPlan(rawSteps);
+    if (plan.length === 0) throw new Error("Could not generate execution plan from steps");
+    const { chromium } = await import("playwright");
+    browser = await chromium.launch({
+      headless: true,
+      ...process.env.PLAYWRIGHT_EXECUTABLE_PATH ? { executablePath: process.env.PLAYWRIGHT_EXECUTABLE_PATH } : {}
+    });
+    let parsedStorageState;
+    try {
+      parsedStorageState = config.storageState ? JSON.parse(config.storageState) : crawlCfg?.storageState ? JSON.parse(crawlCfg.storageState) : void 0;
+    } catch {
+      parsedStorageState = void 0;
+    }
+    const context = await browser.newContext({
+      viewport: { width: 1280, height: 800 },
+      userAgent: await getNonHeadlessUserAgent(process.env.PLAYWRIGHT_EXECUTABLE_PATH || chromium.executablePath()),
+      ...parsedStorageState ? { storageState: parsedStorageState } : {}
+    });
+    const page = await context.newPage();
+    const aiHealingEnabled = await isFeatureEnabled(tenantId, "AI_SELF_HEALING").catch(() => false);
+    const stepResults = [];
+    const screens = [];
+    const locators = [];
+    const seenLocatorExpressions = /* @__PURE__ */ new Set();
+    const seenScreenKeys = /* @__PURE__ */ new Set();
+    let lastStateKey = "";
+    for (let i = 0; i < plan.length; i++) {
+      const step = plan[i];
+      const description = step.description || stepTexts[i] || `Step ${i + 1}`;
+      const stepNumber = i + 1;
+      const result = { stepNumber, description, status: "FAILED" };
+      await withTenant(
+        tenantId,
+        (tx) => tx.platformJob.update({
+          where: { id: jobId },
+          data: {
+            progress: Math.min(90, Math.round(i / Math.max(plan.length, 1) * 90)),
+            result: { currentStep: { stepNumber, description } },
+            heartbeatAt: /* @__PURE__ */ new Date()
+          }
+        })
+      ).catch(() => {
+      });
+      try {
+        const heal = await executeExecutionStep(page, step, aiHealingEnabled ? { healCtx: { tenantId, projectId } } : {});
+        if (heal.healed) {
+          result.healed = true;
+          result.healTier = heal.healedVia;
+          result.healReasoning = heal.healReasoning;
+        }
+        await page.waitForLoadState("networkidle", { timeout: parseInt(process.env.TEST_NETWORK_IDLE_TIMEOUT_MS ?? "2000", 10) }).catch(() => {
+        });
+        result.status = result.healed ? "HEALED" : "PASSED";
+      } catch (err) {
+        result.status = step.optional ? "SKIPPED" : "FAILED";
+        result.error = String(err?.message ?? err).slice(0, 300);
+      }
+      const currentUrl = page.url();
+      result.url = currentUrl;
+      const ssFilename = `${testCaseId}-capture-step-${stepNumber}${result.status === "FAILED" ? "-err" : ""}.png`;
+      const ssPath = path.join(screenshotDir, ssFilename);
+      await page.screenshot({ path: ssPath, fullPage: false }).catch(() => {
+      });
+      result.screenshotPath = ssPath;
+      let cloudUrl;
+      if (tenantStorageCfg) {
+        const key = buildArtifactKey(tenantId, projectId, "screenshots", ssFilename, tenantStorageCfg.prefix);
+        cloudUrl = await uploadScreenshotToTenantStorage(tenantStorageCfg, ssPath, key).catch(() => void 0) ?? void 0;
+        if (cloudUrl) result.screenshotUrl = cloudUrl;
+      }
+      const elements = await domFallbackElements(page).catch(() => []);
+      result.elementsCount = elements.length;
+      const stateHash = hashContent(elements.map((el) => `${el.role}:${el.meaning}:${el.notes ?? ""}`).join("|"));
+      const screenKey = `${currentUrl || "about:blank"}:${stateHash}`;
+      const shouldPersistScreen = currentUrl && currentUrl !== "about:blank" && (i === 0 || screenKey !== lastStateKey || !seenScreenKeys.has(screenKey));
+      lastStateKey = screenKey;
+      if (shouldPersistScreen) {
+        const screenName = screenNameFromUrl(currentUrl, tc.title ?? `Step ${stepNumber}`);
+        const screen = await AppBrain.saveScreen(tenantId, projectId, screenName, currentUrl, jobId, i === 0 ? "ENTRY_POINT" : "LINK_FOLLOW").catch(() => null);
+        if (screen?.id) {
+          result.screenId = screen.id;
+          await AppBrain.saveScreenshot(tenantId, projectId, screen.id, ssPath, screen.version ?? 1, "DESKTOP", cloudUrl).catch(() => {
+          });
+          for (const el of elements) {
+            await AppBrain.saveElement(
+              tenantId,
+              projectId,
+              screen.id,
+              el.meaning,
+              el.role,
+              el.expectedData,
+              el.notes,
+              void 0,
+              true,
+              el.boundingRect,
+              el.ariaState,
+              el.parentLandmark
+            ).catch(() => {
+            });
+          }
+          for (const loc of elementsToPlaywrightLocators(elements)) {
+            if (seenLocatorExpressions.has(loc.expression)) continue;
+            seenLocatorExpressions.add(loc.expression);
+            locators.push(loc);
+          }
+          if (!seenScreenKeys.has(screenKey)) {
+            screens.push({ stepNumber, screenId: screen.id, url: currentUrl, screenshotPath: ssPath, screenshotUrl: cloudUrl, isNewScreen: true });
+            seenScreenKeys.add(screenKey);
+          }
+        }
+      }
+      stepResults.push(result);
+      if (result.status === "FAILED") break;
+    }
+    if (locators.length > 0) {
+      await AppBrain.saveLocatorsJson(tenantId, testCaseId, locators).catch(() => {
+      });
+    }
+    const firstScreen = screens[0];
+    await withTenant(
+      tenantId,
+      (tx) => tx.testCase.update({
+        where: { id: testCaseId },
+        data: {
+          ...firstScreen?.screenId ? { screenId: firstScreen.screenId } : {},
+          captureStepScreenshots: stepResults
+        }
+      })
+    ).catch(() => {
+    });
+    const finalResult = {
+      stepResults,
+      screens,
+      locators,
+      totalSteps: plan.length,
+      capturedScreens: screens.length
+    };
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({
+        where: { id: jobId },
+        data: { status: "DONE", progress: 100, result: finalResult, finishedAt: /* @__PURE__ */ new Date(), heartbeatAt: /* @__PURE__ */ new Date() }
+      })
+    );
+  } catch (err) {
+    const error = String(err?.message ?? err);
+    logger.error({ jobId, testCaseId, err: error }, "processCaptureStepsJob failed");
+    await recordJobFailure(tenantId, jobId, err);
+  } finally {
+    await browser?.close?.().catch(() => {
+    });
+  }
+}
+async function processMultiRoleCrawlJob(jobId, config) {
+  const { tenantId, projectId } = config;
+  try {
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.updateMany({
+        where: { id: jobId, status: { not: "CANCELLED" } },
+        data: { status: "RUNNING", startedAt: /* @__PURE__ */ new Date(), heartbeatAt: /* @__PURE__ */ new Date(), workerId: WORKER_ID }
+      })
+    );
+    await updateJobProgress(tenantId, jobId, 5, "Loading project crawl config\u2026");
+    const proj = await withTenant(
+      tenantId,
+      (tx) => tx.project.findUnique({ where: { id: projectId }, select: { crawlConfig: true } })
+    );
+    const savedCrawlConfig = proj?.crawlConfig ?? {};
+    const credentialProfiles = config.credentialProfiles ?? [];
+    await updateJobProgress(tenantId, jobId, 10, "Enqueuing primary crawl\u2026");
+    const primaryJobId = await enqueueJob("CRAWL", {
+      tenantId,
+      projectId,
+      appUrl: config.appUrl || savedCrawlConfig.appUrl,
+      credentials: savedCrawlConfig.username && savedCrawlConfig.password ? { username: savedCrawlConfig.username, password: savedCrawlConfig.password, ...savedCrawlConfig.totpSecret ? { totpSecret: savedCrawlConfig.totpSecret } : {} } : void 0,
+      storageState: savedCrawlConfig.storageState,
+      screenshotDir: platformConfig.screenshotDir,
+      startUrls: savedCrawlConfig.seedUrls?.length ? savedCrawlConfig.seedUrls : void 0,
+      deviceProfiles: savedCrawlConfig.deviceProfiles ?? ["DESKTOP"],
+      loginInstructions: savedCrawlConfig.loginInstructions,
+      proxyUrl: savedCrawlConfig.proxyUrl,
+      useSitemap: true,
+      sitemapUrl: savedCrawlConfig.sitemapUrl
+    });
+    logger.info({ primaryJobId, projectId }, "[multi-role-crawl] primary CRAWL enqueued");
+    const PRIMARY_TIMEOUT_MS = 2 * 60 * 60 * 1e3;
+    const POLL_INTERVAL_MS = 1e4;
+    const deadline = Date.now() + PRIMARY_TIMEOUT_MS;
+    let primaryStatus = "QUEUED";
+    while (Date.now() < deadline) {
+      const primaryJob = await prismaAdmin.platformJob.findUnique({
+        where: { id: primaryJobId },
+        select: { status: true }
+      }).catch(() => null);
+      primaryStatus = primaryJob?.status ?? "UNKNOWN";
+      if (primaryStatus === "DONE" || primaryStatus === "FAILED" || primaryStatus === "CANCELLED") break;
+      await updateJobProgress(tenantId, jobId, 20, `Waiting for primary crawl (${primaryStatus})\u2026`);
+      await new Promise((res) => setTimeout(res, POLL_INTERVAL_MS));
+    }
+    if (primaryStatus !== "DONE") {
+      throw new Error(`Primary crawl ${primaryJobId} ended with status ${primaryStatus} \u2014 aborting role crawls`);
+    }
+    await updateJobProgress(tenantId, jobId, 50, "Collecting screen URLs for role crawls\u2026");
+    const screens = await prismaAdmin.screen.findMany({
+      where: { tenantId, projectId, status: "ACTIVE" },
+      select: { id: true, url: true }
+    }).catch(() => []);
+    const screenUrls = screens.filter((s) => s.url).map((s) => s.url);
+    logger.info({ screenCount: screenUrls.length, projectId }, "[multi-role-crawl] screen URLs collected");
+    if (credentialProfiles.length === 0) {
+      logger.warn({ projectId, jobId }, "[multi-role-crawl] no credential profiles \u2014 nothing to role-crawl");
+    }
+    const roleJobs = [];
+    for (const profile of credentialProfiles) {
+      if (!profile.username || !profile.password) continue;
+      const roleJobId = await enqueueJob("ROLE_CRAWL", {
+        tenantId,
+        projectId,
+        appUrl: config.appUrl || savedCrawlConfig.appUrl,
+        credentials: { username: profile.username, password: profile.password },
+        roleProfileName: profile.name,
+        parentJobId: jobId,
+        selectiveUrls: config.fullReCrawl ? void 0 : screenUrls.length > 0 ? screenUrls : void 0,
+        startUrls: config.fullReCrawl ? savedCrawlConfig.seedUrls ?? [] : void 0,
+        maxScreens: config.fullReCrawl ? void 0 : screenUrls.length + 10,
+        screenshotDir: platformConfig.screenshotDir,
+        storageState: savedCrawlConfig.storageState,
+        deviceProfiles: savedCrawlConfig.deviceProfiles ?? ["DESKTOP"],
+        loginInstructions: savedCrawlConfig.loginInstructions,
+        proxyUrl: savedCrawlConfig.proxyUrl
+      });
+      roleJobs.push({ roleName: profile.name, jobId: roleJobId });
+      logger.info({ roleJobId, roleName: profile.name, projectId }, "[multi-role-crawl] ROLE_CRAWL enqueued");
+    }
+    const ROLE_TIMEOUT_MS = 2 * 60 * 60 * 1e3;
+    const roleDeadline = Date.now() + ROLE_TIMEOUT_MS;
+    const roleResults = [];
+    while (Date.now() < roleDeadline && roleJobs.length > 0) {
+      const pending = [];
+      for (const rj of roleJobs) {
+        const rJob = await prismaAdmin.platformJob.findUnique({
+          where: { id: rj.jobId },
+          select: { status: true, result: true }
+        }).catch(() => null);
+        const st = rJob?.status ?? "UNKNOWN";
+        if (st === "DONE" || st === "FAILED" || st === "CANCELLED") {
+          roleResults.push({
+            roleName: rj.roleName,
+            jobId: rj.jobId,
+            status: st,
+            screensTagged: rJob?.result?.screensTagged
+          });
+        } else {
+          pending.push(rj);
+        }
+      }
+      roleJobs.length = 0;
+      roleJobs.push(...pending);
+      if (roleJobs.length === 0) break;
+      const pct = Math.round(60 + roleResults.length / (roleResults.length + roleJobs.length) * 35);
+      await updateJobProgress(tenantId, jobId, pct, `Role crawls: ${roleResults.length} done, ${roleJobs.length} pending\u2026`);
+      await new Promise((res) => setTimeout(res, POLL_INTERVAL_MS));
+    }
+    for (const rj of roleJobs) {
+      roleResults.push({ roleName: rj.roleName, jobId: rj.jobId, status: "TIMEOUT" });
+    }
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({
+        where: { id: jobId },
+        data: {
+          status: "DONE",
+          progress: 100,
+          finishedAt: /* @__PURE__ */ new Date(),
+          result: { primaryJobId, roleJobs: roleResults }
+        }
+      })
+    );
+    logger.info({ jobId, primaryJobId, roleCount: roleResults.length, projectId }, "[multi-role-crawl] completed");
+  } catch (err) {
+    const msg = String(err?.message ?? err);
+    logger.error({ jobId, err: msg }, "[multi-role-crawl] failed");
+    await recordJobFailure(tenantId, jobId, err);
+  }
+}
+async function processRoleCrawlJob(jobId, config) {
+  const { tenantId, projectId } = config;
+  try {
+    const claimed = await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.updateMany({
+        where: { id: jobId, status: { not: "CANCELLED" } },
+        data: { status: "RUNNING", startedAt: /* @__PURE__ */ new Date(), heartbeatAt: /* @__PURE__ */ new Date(), workerId: WORKER_ID }
+      })
+    );
+    if (claimed.count === 0) return;
+    const controller = new AbortController();
+    runningControllers.set(jobId, controller);
+    const heartbeatTimer = setInterval(() => void heartbeatJob(tenantId, jobId), JOB_HEARTBEAT_INTERVAL_MS);
+    const onProgress = async (pct, step) => {
+      await updateJobProgress(tenantId, jobId, pct, step);
+    };
+    try {
+      const proj = await withTenant(
+        tenantId,
+        (tx) => tx.project.findUnique({ where: { id: projectId }, select: { crawlConfig: true } })
+      );
+      const savedCrawlConfig = proj?.crawlConfig ?? {};
+      const runtimeCreds = config.credentials ? {
+        ...config.credentials,
+        ...config.credentials.totpSecret ? { getOneTimeCode: async () => generateTOTP(config.credentials.totpSecret) } : {}
+      } : void 0;
+      const storageConfigForCrawl = await getTenantStorageConfig(tenantId).catch(() => null);
+      const result = await crawlProject({
+        ...config,
+        credentials: runtimeCreds,
+        storageState: config.storageState ?? savedCrawlConfig.storageState,
+        proxyUrl: config.proxyUrl ?? savedCrawlConfig.proxyUrl,
+        loginInstructions: config.loginInstructions ?? savedCrawlConfig.loginInstructions,
+        abortSignal: controller.signal,
+        jobId,
+        storageConfig: storageConfigForCrawl
+      }, onProgress);
+      clearInterval(heartbeatTimer);
+      runningControllers.delete(jobId);
+      const roleName = config.roleProfileName;
+      const discovered = result.discovered ?? [];
+      const roleScreenIds = discovered.filter((d) => d.screenId).map((d) => d.screenId);
+      if (roleScreenIds.length > 0 && roleName) {
+        await prismaAdmin.$executeRaw`
+          UPDATE "Screen"
+          SET "roleAccess" = array(SELECT DISTINCT unnest(array_append("roleAccess", ${roleName}::text)))
+          WHERE id = ANY(${roleScreenIds}::text[])
+            AND "tenantId" = ${tenantId}
+        `.catch((e) => logger.warn({ err: e?.message, roleName, count: roleScreenIds.length }, "[role-crawl] roleAccess tag failed (non-fatal)"));
+      }
+      await withTenant(
+        tenantId,
+        (tx) => tx.platformJob.update({
+          where: { id: jobId },
+          data: {
+            status: "DONE",
+            progress: 100,
+            finishedAt: /* @__PURE__ */ new Date(),
+            result: { screensTagged: roleScreenIds.length, roleName }
+          }
+        })
+      );
+      logger.info({ jobId, roleName, screensTagged: roleScreenIds.length, projectId }, "[role-crawl] completed");
+    } catch (err) {
+      clearInterval(heartbeatTimer);
+      runningControllers.delete(jobId);
+      const aborted = String(err).includes("CRAWL_ABORTED");
+      await withTenant(
+        tenantId,
+        (tx) => tx.platformJob.update({
+          where: { id: jobId },
+          data: {
+            status: aborted ? "CANCELLED" : "FAILED",
+            error: aborted ? "Stopped by user" : String(err),
+            finishedAt: /* @__PURE__ */ new Date()
+          }
+        })
+      );
+    } finally {
+      runningControllers.delete(jobId);
+    }
+  } catch (err) {
+    const msg = String(err?.message ?? err);
+    logger.error({ jobId, err: msg }, "[role-crawl] outer failure");
+    await recordJobFailure(tenantId, jobId, err);
+  }
+}
+async function processGenerateScriptJob(jobId, config) {
+  const { tenantId, projectId, language } = config;
+  try {
+    await updateJobProgress(tenantId, jobId, 1, "Loading test cases\u2026").catch(() => {
+    });
+    if (config.packId) {
+      const { assertScriptGenerationReady, generatePackScript } = await import("@taodigital/agents");
+      await assertScriptGenerationReady({ tenantId, projectId, packType: config.packId });
+      const result = await generatePackScript({ tenantId, projectId, packType: config.packId, language });
+      await withTenant(
+        tenantId,
+        (tx) => tx.platformJob.update({
+          where: { id: jobId },
+          data: { status: "DONE", progress: 100, finishedAt: /* @__PURE__ */ new Date(), result }
+        })
+      );
+    } else {
+      const { assertScriptGenerationReady, generateSuiteScript } = await import("@taodigital/agents");
+      await assertScriptGenerationReady({ tenantId, projectId, suiteId: config.suiteId, caseIds: config.caseIds ?? void 0 });
+      let progressChain = Promise.resolve();
+      const result = await generateSuiteScript({
+        tenantId,
+        projectId,
+        suiteId: config.suiteId,
+        language,
+        caseIds: config.caseIds ?? void 0,
+        useV2: config.useV2,
+        styleProfile: config.repoStyleProfile ?? void 0,
+        pageObjectInventory: config.repoPageObjects ?? void 0,
+        jobId,
+        onProgress: (done, total) => {
+          progressChain = progressChain.then(() => updateJobProgress(tenantId, jobId, Math.floor(done / total * 95), `Generated ${done}/${total} scripts`)).catch(() => {
+          });
+        }
+      });
+      await progressChain.catch(() => {
+      });
+      await import("@taodigital/agents").then(({ refreshScriptInventory }) => refreshScriptInventory(tenantId, projectId)).catch((e) => logger.warn({ err: e?.message }, "[generate-script] refreshScriptInventory failed"));
+      await withTenant(
+        tenantId,
+        (tx) => tx.platformJob.update({
+          where: { id: jobId },
+          data: { status: "DONE", progress: 100, finishedAt: /* @__PURE__ */ new Date(), result }
+        })
+      );
+    }
+  } catch (e) {
+    await finishTrackedJob(tenantId, jobId, e?.message ?? "generate-script failed");
+  }
+}
+function queueImportedArtifactSkillRefresh(tenantId, projectId, reason) {
+  setImmediate(() => {
+    import("@taodigital/agents").then((agentsModule) => {
+      const agents = agentsModule;
+      return Promise.allSettled([
+        agents.refreshArtifactKnowledgeSkillFile(tenantId, projectId),
+        agents.refreshRequirementsCoverageSkillFile(tenantId, projectId)
+      ]);
+    }).then((results) => {
+      results?.forEach((result) => {
+        if (result.status === "rejected") {
+          console.warn(`[artifacts] skill refresh failed after ${reason}:`, result.reason?.message ?? result.reason);
+        }
+      });
+    }).catch((e) => console.warn(`[artifacts] skill refresh failed after ${reason}:`, e?.message ?? e));
+  });
+}
+const CONTENT_DETECTED_DOC_TYPES = /* @__PURE__ */ new Set(["FUNCTIONIZE_TC", "SELENIUM_SCRIPT", "ENV_CONFIG"]);
+const AI_DOC_TYPES = /* @__PURE__ */ new Set([
+  "REQUIREMENTS",
+  "USER_STORY",
+  "TEST_CASES",
+  "TEST_DATA",
+  "AUTOMATION_SCRIPT",
+  "API_SPEC",
+  "ARCHITECTURE",
+  "REPORT",
+  "OTHER",
+  "SPREADSHEET",
+  "DATASHEET"
+]);
+const AI_DOC_TYPE_ALIASES = {
+  REQUIREMENT: "REQUIREMENTS",
+  SPEC: "REQUIREMENTS",
+  SPECIFICATION: "REQUIREMENTS",
+  USER_STORIES: "USER_STORY",
+  STORY: "USER_STORY",
+  TEST_CASE: "TEST_CASES",
+  TESTCASES: "TEST_CASES",
+  TESTDATA: "TEST_DATA",
+  SCRIPT: "AUTOMATION_SCRIPT",
+  AUTOMATION: "AUTOMATION_SCRIPT"
+};
+function normalizeAiDocType(raw) {
+  const key = String(raw ?? "").trim().toUpperCase().replace(/[\s-]+/g, "_");
+  const mapped = AI_DOC_TYPE_ALIASES[key] ?? key;
+  return AI_DOC_TYPES.has(mapped) ? mapped : "OTHER";
+}
+async function processArtifactIntelJob(jobId, config) {
+  const { tenantId, projectId, artifactId, artifactName, isReprocess } = config;
+  try {
+    await updateJobProgress(tenantId, jobId, 10, "Downloading artifact content");
+    const artifact = await withTenant(
+      tenantId,
+      (tx) => tx.projectArtifact.findUnique({ where: { id: artifactId }, select: { storageKey: true, docType: true } })
+    );
+    if (!artifact || !artifact.storageKey) {
+      await updateJobProgress(tenantId, jobId, 100, "Artifact deleted or missing content, skipping.");
+      await withTenant(
+        tenantId,
+        (tx) => tx.platformJob.update({ where: { id: jobId }, data: { status: "DONE", finishedAt: /* @__PURE__ */ new Date() } })
+      );
+      return;
+    }
+    const storageCfg = await getTenantStorageConfig(tenantId);
+    if (!storageCfg) {
+      throw new Error("Tenant storage configuration missing.");
+    }
+    const contentBuffer = await downloadBufferFromTenantStorage(storageCfg, artifact.storageKey);
+    const content = contentBuffer.toString("utf8");
+    await updateJobProgress(tenantId, jobId, 40, "Generating intelligence");
+    const intel = await generateArtifactIntelligence(tenantId, projectId, artifactId, content, artifactName, jobId);
+    const finalDocType = artifact.docType && CONTENT_DETECTED_DOC_TYPES.has(artifact.docType) ? artifact.docType : normalizeAiDocType(intel.docType);
+    if (finalDocType !== intel.docType) {
+      await withTenant(
+        tenantId,
+        (tx) => tx.projectArtifact.update({ where: { id: artifactId }, data: { docType: finalDocType } })
+      ).catch((err) => console.warn(`[artifact-intel] docType fix-up failed for "${artifactName}":`, err?.message));
+      intel.docType = finalDocType;
+    }
+    await updateJobProgress(tenantId, jobId, 90, "Saving results");
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({ where: { id: jobId }, data: { result: { artifactId, artifactName, summary: intel.summary, keywords: intel.keywords, docType: intel.docType }, status: "DONE", finishedAt: /* @__PURE__ */ new Date(), progress: 100 } })
+    );
+    queueImportedArtifactSkillRefresh(tenantId, projectId, isReprocess ? "artifact-reprocess" : "artifact-intel");
+  } catch (err) {
+    const msg = String(err?.message ?? err);
+    logger.error({ jobId, err: msg }, "[artifact-intel] failed");
+    await withTenant(
+      tenantId,
+      (tx) => tx.projectArtifact.update({ where: { id: artifactId }, data: { status: "ERROR", summary: "AI analysis failed" } })
+    ).catch(() => {
+    });
+    await recordJobFailure(tenantId, jobId, err);
+    queueImportedArtifactSkillRefresh(tenantId, projectId, "artifact-intel-failed");
+  }
+}
+async function processPostmanRunJob(jobId, config) {
+  const { tenantId, projectId, runId, collection, environment, timeoutMs = 3e5 } = config;
+  await withTenant(
+    tenantId,
+    (tx) => tx.platformJob.update({ where: { id: jobId }, data: { status: "RUNNING", startedAt: /* @__PURE__ */ new Date() } })
+  );
+  let historyId = null;
+  try {
+    await updateJobProgress(tenantId, jobId, 10, "Preparing Newman run");
+    const tmpDir = path.join(os.tmpdir(), "zeta-newman", String(runId ?? jobId));
+    await fs.mkdir(tmpDir, { recursive: true });
+    try {
+      const hist = await prismaAdmin.apiTestRunHistory.create({
+        data: { tenantId, projectId, status: "running", source: "newman" },
+        select: { id: true }
+      });
+      historyId = hist.id;
+    } catch {
+    }
+    const collectionPath = path.join(tmpDir, "collection.json");
+    const envPath = path.join(tmpDir, "environment.json");
+    const resultsPath = path.join(tmpDir, "results.json");
+    await fs.writeFile(collectionPath, JSON.stringify(collection ?? {}));
+    if (environment) await fs.writeFile(envPath, JSON.stringify(environment));
+    const iterationDataPath = path.join(tmpDir, "iteration-data.json");
+    if (config.iterationDataJson) {
+      await fs.writeFile(iterationDataPath, config.iterationDataJson);
+    }
+    const newmanArgs = [
+      "--yes",
+      "newman",
+      "run",
+      collectionPath,
+      ...environment ? ["-e", envPath] : [],
+      ...config.iterationDataJson ? ["--iteration-data", iterationDataPath] : [],
+      "--reporters",
+      "json",
+      "--reporter-json-export",
+      resultsPath,
+      "--timeout",
+      String(timeoutMs),
+      "--suppress-exit-code",
+      "--disable-unicode"
+    ];
+    await updateJobProgress(tenantId, jobId, 30, "Running Newman");
+    await new Promise((resolve, reject) => {
+      const proc = spawn("npx", newmanArgs, {
+        cwd: tmpDir,
+        timeout: timeoutMs + 1e4,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      proc.on("close", () => resolve());
+      proc.on("error", reject);
+    });
+    await updateJobProgress(tenantId, jobId, 80, "Parsing Newman results");
+    let summary = { total: 0, passed: 0, failed: 0, skipped: 0, durationMs: 0 };
+    try {
+      const raw = await fs.readFile(resultsPath, "utf-8");
+      const results = JSON.parse(raw);
+      const executions = results.run?.executions ?? [];
+      for (const exec of executions) {
+        const assertions = exec.assertions ?? [];
+        const failed = assertions.filter((a) => !!a.error).length;
+        const status = failed === 0 ? "passed" : "failed";
+        summary.total++;
+        if (status === "passed") summary.passed++;
+        else summary.failed++;
+      }
+      const timings = results.run?.timings ?? {};
+      summary.durationMs = (timings.completed ?? 0) - (timings.started ?? 0);
+      logger.info({ tenantId, projectId, runId, jobId, ...summary }, "[newman] run complete");
+      if (historyId) {
+        const requestRows = executions.map((exec) => {
+          const assertions = exec.assertions ?? [];
+          const failed = assertions.filter((a) => !!a.error).length;
+          return {
+            runHistoryId: historyId,
+            requestName: exec.item?.name ?? exec.item?.id ?? "Unknown",
+            status: failed === 0 ? "passed" : "failed",
+            statusCode: exec.response?.code ?? null,
+            durationMs: exec.response?.responseTime ?? null,
+            assertions: assertions.length > 0 ? assertions : void 0,
+            requestUrl: exec.request?.url?.raw ?? null,
+            error: failed > 0 ? assertions.find((a) => a.error)?.error?.message ?? "Assertion failed" : null
+          };
+        });
+        try {
+          await prismaAdmin.apiTestRunRequest.createMany({ data: requestRows });
+          await prismaAdmin.apiTestRunHistory.update({
+            where: { id: historyId },
+            data: {
+              status: summary.failed > 0 ? "failed" : "passed",
+              summary,
+              completedAt: /* @__PURE__ */ new Date()
+            }
+          });
+        } catch (e) {
+        }
+      }
+    } catch (err) {
+      logger.error({ err, jobId }, "[newman] failed to parse results");
+    }
+    await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {
+    });
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({
+        where: { id: jobId },
+        data: { status: "DONE", progress: 100, finishedAt: /* @__PURE__ */ new Date(), result: summary }
+      })
+    );
+  } catch (err) {
+    logger.error({ jobId, err: String(err?.message ?? err) }, "[newman] job failed");
+    if (historyId) {
+      await prismaAdmin.apiTestRunHistory.update({
+        where: { id: historyId },
+        data: { status: "error", completedAt: /* @__PURE__ */ new Date() }
+      }).catch(() => {
+      });
+    }
+    await recordJobFailure(tenantId, jobId, err);
+  }
+}
+jobDispatchTable = {
+  ARTIFACT_INTEL: processArtifactIntelJob,
+  CRAWL: processJob,
+  CAPTURE_STEPS: processCaptureStepsJob,
+  DISCOVER: processDiscoverJob,
+  MONITOR: processMonitorJob,
+  NATIVE_CRAWL: processNativeCrawlJob,
+  API_TESTS: processApiTestsJob,
+  SECURITY_TESTS: processSecurityTestsJob,
+  INTEGRATION_TESTS: processIntegrationTestsJob,
+  FIGMA_IMPORT: processFigmaImportJob,
+  GENERATE_SKILL_FILES: processGenerateSkillFilesJob,
+  GENERATE_TESTS_FROM_REQS: processGenerateTestsFromReqsJob,
+  GENERATE_SCREEN_TESTS: processGenerateScreenTestsJob,
+  RUN_TEST_SUITE: processRunTestSuiteJob,
+  REPO_SCAN: processRepoScanJob,
+  IMPORT_TESTS: processImportTestsJob,
+  BATCH_GENERATE_ALIGNED: processBatchGenerateAlignedJob,
+  CREATE_PR: processCreatePRJob,
+  NEW_PAGES_PIPELINE: processNewPagesPipelineJob,
+  MULTI_ROLE_CRAWL: processMultiRoleCrawlJob,
+  ROLE_CRAWL: processRoleCrawlJob,
+  GENERATE_SCRIPT: processGenerateScriptJob,
+  POSTMAN_RUN: processPostmanRunJob,
+  // The following job types are still processed in-process by the API.
+  // If the worker claims one, the API crashed after creating it — mark failed so it's visible.
+  GENERATE_TESTS: async (jobId, _config) => {
+    logger.error({ jobId }, "[job-worker] GENERATE_TESTS claimed by worker \u2014 API did not process it in-process");
+    await prismaAdmin.platformJob.update({
+      where: { id: jobId },
+      data: { status: "FAILED", error: "Test generation was not completed by the API \u2014 please retry from the UI.", finishedAt: /* @__PURE__ */ new Date() }
+    }).catch(() => {
+    });
+  },
+  GENERATE_DATA: async (jobId, _config) => {
+    logger.error({ jobId }, "[job-worker] GENERATE_DATA claimed by worker \u2014 API did not process it in-process");
+    await prismaAdmin.platformJob.update({
+      where: { id: jobId },
+      data: { status: "FAILED", error: "Data generation was not completed by the API \u2014 please retry from the UI.", finishedAt: /* @__PURE__ */ new Date() }
+    }).catch(() => {
+    });
+  },
+  GENERATE_TEST_PLAN: async (jobId, _config) => {
+    logger.error({ jobId }, "[job-worker] GENERATE_TEST_PLAN claimed by worker \u2014 API did not process it in-process");
+    await prismaAdmin.platformJob.update({
+      where: { id: jobId },
+      data: { status: "FAILED", error: "Test plan generation was not completed by the API \u2014 please retry from the UI.", finishedAt: /* @__PURE__ */ new Date() }
+    }).catch(() => {
+    });
+  },
+  SCREENSHOT_ENHANCE: async (jobId, config) => {
+    const { tenantId, projectId } = config;
+    const jobStartedAt = /* @__PURE__ */ new Date();
+    await prismaAdmin.platformJob.update({ where: { id: jobId }, data: { status: "RUNNING", startedAt: jobStartedAt } }).catch(() => {
+    });
+    try {
+      const cfg = config;
+      const { analyzeScreenshotForEnhancement, diffScreenshotElementsAgainstTestCases, updateProjectContextSources } = await import("@taodigital/agents");
+      const artifact = await prismaAdmin.projectArtifact?.findFirst({ where: { id: cfg.artifactId, tenantId } }) ?? await prismaAdmin.artifact?.findFirst({ where: { id: cfg.artifactId, tenantId } });
+      if (!artifact) {
+        await prismaAdmin.platformJob.update({ where: { id: jobId }, data: { status: "DONE", finishedAt: /* @__PURE__ */ new Date(), result: { skipped: true, reason: "artifact not found" } } }).catch(() => {
+        });
+        return;
+      }
+      let imageBase64 = "";
+      if (artifact.cloudUrl) {
+        try {
+          const res = await fetch(artifact.cloudUrl);
+          const buf = await res.arrayBuffer();
+          imageBase64 = Buffer.from(buf).toString("base64");
+        } catch (_) {
+        }
+      }
+      const analysisResult = await analyzeScreenshotForEnhancement(tenantId, projectId, cfg.artifactId, imageBase64);
+      const testCases = await prismaAdmin.testCase.findMany({ where: { tenantId, projectId }, take: 100 });
+      const payload = await diffScreenshotElementsAgainstTestCases(tenantId, projectId, analysisResult.elements, testCases);
+      const enhancement = await prismaAdmin.contextEnhancement.create({
+        data: { tenantId, projectId, sourceType: "SCREENSHOT", sourceRef: cfg.artifactId, status: payload.proposedChanges.length > 0 ? "DIFF_READY" : "APPROVED", proposedChanges: payload.proposedChanges }
+      });
+      if (analysisResult.elements.length > 0) {
+        await prismaAdmin.extractedElement.createMany({ data: analysisResult.elements.map((el) => ({ tenantId, projectId, sourceEnhancementId: enhancement.id, ...el })) }).catch(() => {
+        });
+      }
+      await updateProjectContextSources(tenantId, projectId, "SCREENSHOT", { count: 1 });
+      await prismaAdmin.platformJob.update({ where: { id: jobId }, data: { status: "DONE", finishedAt: /* @__PURE__ */ new Date(), progress: 100, result: { enhancementId: enhancement.id, elementsFound: analysisResult.elements.length, changesProposed: payload.proposedChanges.length } } }).catch(() => {
+      });
+    } catch (err) {
+      await recordJobFailure(tenantId, jobId, err);
+    }
+  },
+  FIGMA_ENHANCE: async (jobId, config) => {
+    const { tenantId, projectId } = config;
+    const jobStartedAt = /* @__PURE__ */ new Date();
+    await prismaAdmin.platformJob.update({ where: { id: jobId }, data: { status: "RUNNING", startedAt: jobStartedAt } }).catch(() => {
+    });
+    try {
+      const { analyzeFigmaComponentsForEnhancement, updateProjectContextSources } = await import("@taodigital/agents");
+      const figmaComponents = await prismaAdmin.figmaComponent.findMany({ where: { tenantId, projectId } });
+      const testCases = await prismaAdmin.testCase.findMany({ where: { tenantId, projectId }, take: 100 });
+      const payload = await analyzeFigmaComponentsForEnhancement(tenantId, projectId, figmaComponents, testCases);
+      const enhancement = await prismaAdmin.contextEnhancement.create({
+        data: { tenantId, projectId, sourceType: "FIGMA", status: payload.proposedChanges.length > 0 ? "DIFF_READY" : "APPROVED", proposedChanges: payload.proposedChanges }
+      });
+      await updateProjectContextSources(tenantId, projectId, "FIGMA", { importedAt: (/* @__PURE__ */ new Date()).toISOString() });
+      await prismaAdmin.platformJob.update({ where: { id: jobId }, data: { status: "DONE", finishedAt: /* @__PURE__ */ new Date(), progress: 100, result: { enhancementId: enhancement.id, changesProposed: payload.proposedChanges.length } } }).catch(() => {
+      });
+    } catch (err) {
+      await recordJobFailure(tenantId, jobId, err);
+    }
+  },
+  CRAWL_DIFF: async (jobId, config) => {
+    const { tenantId, projectId } = config;
+    const jobStartedAt = /* @__PURE__ */ new Date();
+    await prismaAdmin.platformJob.update({ where: { id: jobId }, data: { status: "RUNNING", startedAt: jobStartedAt } }).catch(() => {
+    });
+    try {
+      const { computeCrawlDiffs } = await import("@taodigital/agents");
+      const { fromJobId, toJobId } = config;
+      const result = await computeCrawlDiffs(tenantId, projectId, fromJobId, toJobId);
+      await prismaAdmin.platformJob.update({ where: { id: jobId }, data: { status: "DONE", finishedAt: /* @__PURE__ */ new Date(), progress: 100, result } }).catch(() => {
+      });
+    } catch (err) {
+      await recordJobFailure(tenantId, jobId, err);
+    }
+  },
+  ANALYZE_FAILURES: async (jobId, config) => {
+    const { tenantId, projectId } = config;
+    const jobStartedAt = /* @__PURE__ */ new Date();
+    await prismaAdmin.platformJob.update({ where: { id: jobId }, data: { status: "RUNNING", startedAt: jobStartedAt } }).catch(() => {
+    });
+    try {
+      const { analyzeTestRunFailures, computeRequirementCoverage, computeCoverageGaps } = await import("@taodigital/agents");
+      const { runId } = config;
+      const [failures, coverage, gaps] = await Promise.all([
+        analyzeTestRunFailures(tenantId, projectId, runId),
+        computeRequirementCoverage(tenantId, projectId),
+        computeCoverageGaps(tenantId, projectId)
+      ]);
+      await prismaAdmin.platformJob.update({ where: { id: jobId }, data: { status: "DONE", finishedAt: /* @__PURE__ */ new Date(), progress: 100, result: { failures, coverage, gaps } } }).catch(() => {
+      });
+    } catch (err) {
+      await recordJobFailure(tenantId, jobId, err);
+    }
+  }
+};
+async function processRepoScanJob(jobId, config) {
+  const { repoConnectionId, tenantId, projectId } = config;
+  const jobStart = /* @__PURE__ */ new Date();
+  try {
+    await updateJobProgress(tenantId, jobId, 5, "Starting repo scan");
+    const {
+      fetchRepoTree,
+      fetchFileContent,
+      detectFramework,
+      extractTestIds,
+      extractStyleProfile,
+      buildPageObjectInventory,
+      resolveFixtureAliasesFromImports
+    } = await import("@taodigital/agents");
+    const conn = await withTenant(
+      tenantId,
+      (tx) => tx.gitHubRepoConnection.findFirst({ where: { id: repoConnectionId, tenantId } })
+    );
+    if (!conn) throw new Error(`RepoConnection ${repoConnectionId} not found`);
+    const { decrypt: decrypt2 } = await import("@taodigital/core");
+    const token = decrypt2(conn.tokenEnc);
+    await withTenant(
+      tenantId,
+      (tx) => tx.gitHubRepoConnection.update({ where: { id: repoConnectionId }, data: { scanStatus: "SCANNING", scanError: null } })
+    );
+    await updateJobProgress(tenantId, jobId, 15, "Fetching repo tree");
+    const treeResult = await fetchRepoTree(token, conn.repoFullName, "HEAD");
+    if (treeResult.truncated) {
+      console.warn(`[repo-scan] ${conn.repoFullName}: tree truncated (>100k blobs) \u2014 detection may be incomplete`);
+      await withTenant(
+        tenantId,
+        (tx) => tx.gitHubRepoConnection.update({
+          where: { id: repoConnectionId },
+          data: { scanError: "Repository tree was truncated by GitHub (>100k files) \u2014 some test files in deep subdirectories may be missing from this scan." }
+        })
+      );
+    }
+    const frameworks = detectFramework(treeResult.paths);
+    const primary = frameworks[0];
+    await updateJobProgress(tenantId, jobId, 30, `Detected framework: ${primary?.framework ?? "unknown"}`);
+    const storedGlob = conn.testGlob || "";
+    const testGlob = storedGlob && storedGlob !== "**/*.spec.ts" ? storedGlob : primary?.testGlob || storedGlob || "**/*.spec.ts";
+    const framework = primary?.framework ?? "unknown";
+    const language = primary?.language ?? "typescript";
+    const { minimatch } = await import("minimatch").catch(() => ({ minimatch: null }));
+    const isPythonTestFile = (p) => p.endsWith(".py") && !p.endsWith("__init__.py") && !p.endsWith("conftest.py") && (p.endsWith("_test.py") || /\/test_[^/]+\.py$/.test(p) || /^test_[^/]+\.py$/.test(p) || p.includes("/tests/") || p.includes("/test/"));
+    const isJavaTestFile = (p) => p.endsWith(".java") && (/[A-Z]\w*Tests?\.java$/.test(p) || /\/tests?\//.test(p) && /[A-Z][a-z]/.test(p.split("/").pop() ?? ""));
+    const testGlobs = minimatch ? Array.from(/* @__PURE__ */ new Set([
+      testGlob,
+      ...testGlob === "**/*.spec.ts" ? ["**/*.test.ts", "**/*.cy.ts"] : [],
+      ...testGlob === "**/*.spec.js" ? ["**/*.test.js", "**/*.cy.js"] : []
+    ])) : [];
+    const testPaths = treeResult.paths.filter((p) => {
+      if (language === "java") return isJavaTestFile(p);
+      if (language === "python") return isPythonTestFile(p);
+      if (testGlobs.length) return testGlobs.some((g) => minimatch(p, g, { matchBase: true }));
+      return p.endsWith(".spec.ts") || p.endsWith(".spec.js") || p.endsWith(".test.ts") || p.endsWith(".test.js") || p.endsWith(".cy.ts") || p.endsWith(".cy.js") || p.endsWith("_test.py") || p.includes("/test_");
+    }).slice(0, 2e3);
+    await updateJobProgress(tenantId, jobId, 40, `Found ${testPaths.length} test files`);
+    if (testPaths.length === 0) {
+      logger.warn({ jobId, repoConnectionId, framework }, "[repo-scan] no test files matched glob \u2014 scan complete with 0 results");
+      await withTenant(
+        tenantId,
+        (tx) => tx.gitHubRepoConnection.update({
+          where: { id: repoConnectionId },
+          data: { scanStatus: "DONE", testFileCount: 0, extractedIdCount: 0, lastScannedAt: /* @__PURE__ */ new Date(), lastSyncAt: /* @__PURE__ */ new Date() }
+        })
+      );
+      await updateJobProgress(tenantId, jobId, 100, "Done: 0 test files found");
+      await withTenant(
+        tenantId,
+        (tx) => tx.platformJob.update({ where: { id: jobId }, data: { status: "DONE", finishedAt: /* @__PURE__ */ new Date(), result: { testFileCount: 0, extractedIdCount: 0 } } })
+      );
+      return;
+    }
+    const allExtracted = [];
+    const styleSampleFiles = [];
+    let processed = 0;
+    await withTenant(tenantId, (tx) => tx.repoTestFile.deleteMany({ where: { repoConnectionId } }));
+    for (const filePath of testPaths) {
+      const content = await fetchFileContent(token, conn.repoFullName, filePath);
+      if (!content) continue;
+      const extraAliases = await resolveFixtureAliasesFromImports(
+        content,
+        token,
+        conn.repoFullName,
+        filePath
+      ).catch(() => /* @__PURE__ */ new Set());
+      const extracted = extractTestIds(content, filePath, framework, extraAliases);
+      allExtracted.push(...extracted);
+      await withTenant(
+        tenantId,
+        (tx) => tx.repoTestFile.create({
+          data: {
+            tenantId,
+            projectId,
+            repoConnectionId,
+            filePath,
+            framework,
+            extractedIds: extracted.map((e) => ({ name: e.name, normalizedName: e.normalizedName, lineNumber: e.lineNumber })),
+            rawSample: content.slice(0, 2e3),
+            lastScannedAt: /* @__PURE__ */ new Date()
+          }
+        })
+      );
+      if (styleSampleFiles.length < 5) styleSampleFiles.push({ path: filePath, content: content.slice(0, 3e3) });
+      processed++;
+      if (processed % 10 === 0) {
+        await updateJobProgress(tenantId, jobId, 40 + Math.floor(processed / testPaths.length * 40), `Processed ${processed}/${testPaths.length} files`);
+      }
+    }
+    const configPaths = {};
+    try {
+      const pathSet = new Set(treeResult.paths);
+      const lang = framework.includes("java") ? "java" : framework.includes("py") || framework === "pytest" ? "python" : "js";
+      const configFilesToFetch = [];
+      const tryAdd = (candidates, type) => {
+        for (const c of candidates) {
+          if (pathSet.has(c)) {
+            configFilesToFetch.push({ path: c, type, dirPrefix: "" });
+            break;
+          }
+        }
+      };
+      const scanTree = (pattern, type) => {
+        if (configFilesToFetch.some((f) => f.type === type)) return;
+        const all = treeResult.paths.filter((p) => pattern.test(p)).sort((a, b) => a.split("/").length - b.split("/").length);
+        if (all[0]) {
+          const lastSlash = all[0].lastIndexOf("/");
+          const dirPrefix = lastSlash > 0 ? all[0].slice(0, lastSlash + 1) : "";
+          configFilesToFetch.push({ path: all[0], type, dirPrefix });
+        }
+      };
+      if (lang === "js") {
+        if (framework.startsWith("playwright")) {
+          tryAdd(["playwright.config.ts", "playwright.config.js"], "playwright");
+          scanTree(/(?:^|\/)playwright\.config\.(ts|js|mts)$/, "playwright");
+        }
+        if (framework.startsWith("cypress")) {
+          tryAdd(["cypress.config.ts", "cypress.config.js"], "cypress");
+          scanTree(/(?:^|\/)cypress\.config\.(ts|js)$/, "cypress");
+        }
+        if (framework === "jest-ts" || framework === "jest-js") {
+          tryAdd(["jest.config.ts", "jest.config.js", "jest.config.mjs"], "jest");
+          scanTree(/(?:^|\/)jest\.config\.(ts|js|mjs|cjs)$/, "jest");
+          tryAdd(["package.json"], "package-json");
+        }
+        if (framework === "webdriverio") {
+          tryAdd(["wdio.conf.ts", "wdio.conf.js", "wdio.config.ts", "wdio.config.js"], "wdio");
+          scanTree(/(?:^|\/)wdio\.(?:conf|config)\.(ts|js|mjs)$/, "wdio");
+        }
+        if (framework === "cucumber" || framework === "gherkin") {
+          tryAdd([".cucumber.js", ".cucumber.cjs", "cucumber.json", ".cucumber.yaml", ".cucumber.yml"], "cucumber");
+          tryAdd(["package.json"], "package-json");
+        }
+        tryAdd(["tsconfig.json"], "tsconfig");
+        scanTree(/(?:^|\/)tsconfig(?:\.base)?\.json$/, "tsconfig");
+      } else if (lang === "python") {
+        tryAdd(["pytest.ini"], "pytest-ini");
+        scanTree(/(?:^|\/)pytest\.ini$/, "pytest-ini");
+        tryAdd(["pyproject.toml"], "pyproject-toml");
+        scanTree(/(?:^|\/)pyproject\.toml$/, "pyproject-toml");
+        tryAdd(["setup.cfg"], "setup-cfg");
+      } else if (lang === "java") {
+        tryAdd(["pom.xml"], "pom-xml");
+        scanTree(/(?:^|\/)pom\.xml$/, "pom-xml");
+        tryAdd(["build.gradle.kts", "build.gradle"], "build-gradle");
+        scanTree(/(?:^|\/)build\.gradle(?:\.kts)?$/, "build-gradle");
+        tryAdd(["testng.xml", "src/test/resources/testng.xml"], "testng-xml");
+      }
+      const normDir = (s) => s.replace(/^\.\//, "").replace(/\/$/, "");
+      const globRoot = (pattern) => {
+        const root = pattern.replace(/\/\*\*.*$/, "").replace(/\/\*[^*].*$/, "");
+        return root && !root.startsWith("*") && !root.startsWith("{") ? normDir(root) : null;
+      };
+      const fetched = await Promise.all(
+        configFilesToFetch.map(async ({ path: cfgPath, type, dirPrefix }) => {
+          const content = await fetchFileContent(token, conn.repoFullName, cfgPath).catch(() => null);
+          if (!content) return null;
+          const r = {};
+          if (type === "playwright") {
+            const m = content.match(/\btestDir\s*:\s*['"`]([^'"`]+)['"`]/);
+            if (m) r.testDir = normDir(m[1]);
+            const bm = content.match(/\bbaseURL\s*:\s*['"`]([^'"`]+)['"`]/);
+            if (bm) r.baseURL = bm[1];
+          } else if (type === "cypress") {
+            const sm = content.match(/\bspecPattern\s*:\s*['"`]([^'"`]+)['"`]/);
+            if (sm) {
+              const gr = globRoot(sm[1]);
+              if (gr) r.testDir = gr;
+            }
+            const fm = content.match(/\bfixturesFolder\s*:\s*['"`]([^'"`]+)['"`]/);
+            if (fm) r.fixturesFolder = normDir(fm[1]);
+            const bm = content.match(/\bbaseUrl\s*:\s*['"`]([^'"`]+)['"`]/);
+            if (bm) r.baseURL = bm[1];
+          } else if (type === "jest") {
+            const rm = content.match(/\broots\s*:\s*\[([^\]]+)\]/);
+            if (rm) {
+              const fr = rm[1].match(/['"`]([^'"`]+)['"`]/)?.[1];
+              if (fr) r.testDir = fr.replace(/<rootDir>\/?/, "").replace(/\/$/, "") || "src";
+            }
+            if (!r.testDir) {
+              const tm = content.match(/\btestMatch\s*:\s*\[([^\]]+)\]/);
+              if (tm) {
+                const fp = tm[1].match(/['"`]([^'"`]+)['"`]/)?.[1];
+                if (fp) {
+                  const gr = globRoot(fp.replace(/<rootDir>\/?/, ""));
+                  if (gr) r.testDir = gr;
+                }
+              }
+            }
+            const mm = content.match(/\bmoduleNameMapper\s*:\s*\{([^}]+)\}/s);
+            if (mm) {
+              const map = {};
+              for (const [, k, v] of mm[1].matchAll(/['"`]([^'"`]+)['"`]\s*:\s*['"`]([^'"`]+)['"`]/g)) map[k] = v;
+              if (Object.keys(map).length) r.jestModuleNameMapper = map;
+            }
+          } else if (type === "package-json") {
+            try {
+              const p = JSON.parse(content);
+              const j = p?.jest ?? {};
+              if (Array.isArray(j.roots) && j.roots[0]) r.testDir = String(j.roots[0]).replace(/<rootDir>\/?/, "").replace(/\/$/, "") || "src";
+              if (!r.testDir && Array.isArray(j.testMatch) && j.testMatch[0]) {
+                const gr = globRoot(String(j.testMatch[0]).replace(/<rootDir>\/?/, ""));
+                if (gr) r.testDir = gr;
+              }
+              if (j.moduleNameMapper && typeof j.moduleNameMapper === "object") r.jestModuleNameMapper = j.moduleNameMapper;
+            } catch {
+            }
+          } else if (type === "tsconfig") {
+            try {
+              const stripped = content.replace(/\/\/[^\n]*/g, "").replace(/,(\s*[}\]])/g, "$1");
+              const p = JSON.parse(stripped);
+              const opts = p?.compilerOptions ?? {};
+              if (opts.paths && typeof opts.paths === "object") r.tsconfigPaths = opts.paths;
+              if (typeof opts.baseUrl === "string") r.tsconfigBaseUrl = opts.baseUrl;
+            } catch {
+            }
+          } else if (type === "pytest-ini") {
+            const m = content.match(/^\s*testpaths\s*=\s*(.+)$/m);
+            if (m) {
+              const first = m[1].trim().split(/\s+/)[0];
+              if (first) r.testDir = normDir(first);
+            }
+          } else if (type === "pyproject-toml") {
+            const m = content.match(/testpaths\s*=\s*\[([^\]]+)\]/);
+            if (m) {
+              const first = m[1].match(/['"]([^'"]+)['"]/)?.[1];
+              if (first) r.testDir = normDir(first);
+            }
+            if (!r.testDir) {
+              const m2 = content.match(/testpaths\s*=\s*['"]([^'"]+)['"]/);
+              if (m2) r.testDir = normDir(m2[1]);
+            }
+          } else if (type === "setup-cfg") {
+            const m = content.match(/^\s*testpaths\s*=\s*(.+)$/m);
+            if (m) {
+              const first = m[1].trim().split(/[\s,]+/)[0];
+              if (first) r.testDir = normDir(first);
+            }
+          } else if (type === "pom-xml") {
+            const m = content.match(/<testSourceDirectory>\s*([^<]+)\s*<\/testSourceDirectory>/);
+            if (m) r.javaTestSourceDir = normDir(m[1].trim());
+          } else if (type === "build-gradle") {
+            const m = content.match(/srcDir[s]?\s*[=([]?\s*['"`]([^'"`]+)['"`]/) ?? content.match(/srcDir\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/);
+            if (m) r.javaTestSourceDir = normDir(m[1]);
+          } else if (type === "wdio") {
+            const sm = content.match(/\bspecs\s*:\s*\[([^\]]+)\]/);
+            if (sm) {
+              const fp = sm[1].match(/['"`]([^'"`]+)['"`]/)?.[1];
+              if (fp) {
+                const gr = globRoot(fp);
+                if (gr) r.testDir = gr;
+              }
+            }
+            const bm = content.match(/\bbaseUrl\s*:\s*['"`]([^'"`]+)['"`]/);
+            if (bm) r.baseURL = bm[1];
+          } else if (type === "cucumber") {
+            const pm = content.match(/\bpaths\s*:\s*\[([^\]]+)\]/);
+            if (pm) {
+              const fp = pm[1].match(/['"`]([^'"`]+)['"`]/)?.[1];
+              if (fp) {
+                const gr = globRoot(fp);
+                if (gr) r.testDir = gr;
+              }
+            }
+            if (!r.testDir) {
+              try {
+                const p = JSON.parse(content);
+                const paths = p?.default?.paths ?? p?.paths;
+                if (Array.isArray(paths) && paths[0]) {
+                  const gr = globRoot(String(paths[0]));
+                  if (gr) r.testDir = gr;
+                }
+              } catch {
+              }
+            }
+          }
+          if (dirPrefix && r.testDir && !r.testDir.startsWith(dirPrefix)) {
+            r.testDir = dirPrefix + r.testDir;
+          }
+          if (dirPrefix && r.javaTestSourceDir && !r.javaTestSourceDir.startsWith(dirPrefix)) {
+            r.javaTestSourceDir = dirPrefix + r.javaTestSourceDir;
+          }
+          return r;
+        })
+      );
+      for (const parsed of fetched) {
+        if (!parsed) continue;
+        if (parsed.testDir && !configPaths.testDir) configPaths.testDir = parsed.testDir;
+        if (parsed.fixturesFolder && !configPaths.fixturesFolder) configPaths.fixturesFolder = parsed.fixturesFolder;
+        if (parsed.baseURL && !configPaths.baseURL) configPaths.baseURL = parsed.baseURL;
+        if (parsed.tsconfigPaths && !configPaths.tsconfigPaths) configPaths.tsconfigPaths = parsed.tsconfigPaths;
+        if (parsed.tsconfigBaseUrl && !configPaths.tsconfigBaseUrl) configPaths.tsconfigBaseUrl = parsed.tsconfigBaseUrl;
+        if (parsed.javaTestSourceDir && !configPaths.javaTestSourceDir) configPaths.javaTestSourceDir = parsed.javaTestSourceDir;
+        if (parsed.jestModuleNameMapper && !configPaths.jestModuleNameMapper) configPaths.jestModuleNameMapper = parsed.jestModuleNameMapper;
+      }
+    } catch {
+    }
+    let styleProfile = conn.styleProfile ?? null;
+    if (styleSampleFiles.length > 0) {
+      try {
+        const mainSourcePaths = language === "java" ? treeResult.paths.filter((p) => /^src\/main\/java\//.test(p)).slice(0, 50) : [];
+        const testPathSet = new Set(testPaths);
+        const sourceFilePaths = language === "typescript" || language === "javascript" ? treeResult.paths.filter((p) => (p.endsWith(".ts") || p.endsWith(".js")) && !testPathSet.has(p) && !p.endsWith(".d.ts") && !p.includes("node_modules/") && !p.includes("dist/") && !p.includes(".config.")).slice(0, 60) : [];
+        const allPathsForProfile = [...testPaths, ...mainSourcePaths, ...sourceFilePaths].slice(0, 200);
+        const freshProfile = await extractStyleProfile(styleSampleFiles, framework, language, tenantId, projectId, jobId, allPathsForProfile, treeResult.paths);
+        if (freshProfile) styleProfile = freshProfile;
+      } catch {
+      }
+    }
+    if (styleProfile && Object.keys(configPaths).length > 0) {
+      if (configPaths.testDir) styleProfile.configTestDir = configPaths.testDir;
+      if (configPaths.javaTestSourceDir) {
+        styleProfile.configTestDir = configPaths.javaTestSourceDir;
+        if (!styleProfile.testLocation) styleProfile.testLocation = configPaths.javaTestSourceDir;
+      }
+      if (configPaths.fixturesFolder) styleProfile.configFixturesFolder = configPaths.fixturesFolder;
+      if (configPaths.baseURL) styleProfile.configBaseURL = configPaths.baseURL;
+      if (configPaths.tsconfigPaths) styleProfile.tsconfigPaths = configPaths.tsconfigPaths;
+      if (configPaths.tsconfigBaseUrl) styleProfile.tsconfigBaseUrl = configPaths.tsconfigBaseUrl;
+      if (configPaths.jestModuleNameMapper) styleProfile.jestModuleNameMapper = configPaths.jestModuleNameMapper;
+    }
+    let pageObjectInventory = conn.pageObjectInventory ?? [];
+    try {
+      const freshInventory = await buildPageObjectInventory(token, conn.repoFullName, treeResult.paths, framework);
+      if (freshInventory.length > 0) {
+        pageObjectInventory = freshInventory;
+        await updateJobProgress(tenantId, jobId, 82, `Found ${pageObjectInventory.length} page objects`);
+      }
+    } catch {
+    }
+    await updateJobProgress(tenantId, jobId, 85, "Running coverage mapping");
+    const { buildCoverageMap } = await import("@taodigital/agents");
+    const testCases = await withTenant(
+      tenantId,
+      (tx) => tx.testCase.findMany({ where: { projectId, tenantId, status: { not: "RETIRED" } }, select: { id: true, title: true, ref: true } })
+    );
+    const mappings = await buildCoverageMap(testCases, allExtracted, tenantId);
+    for (const m of mappings) {
+      const existing = await withTenant(
+        tenantId,
+        (tx) => tx.coverageMapping.findUnique({ where: { testCaseId: m.testCaseId } })
+      );
+      if (existing?.manualOverride) continue;
+      await withTenant(
+        tenantId,
+        (tx) => tx.coverageMapping.upsert({
+          where: { testCaseId: m.testCaseId },
+          create: { tenantId, projectId, testCaseId: m.testCaseId, repoConnectionId, status: m.status, matchedFilePath: m.matchedFilePath ?? null, scriptTestName: m.scriptTestName ?? null, lineNumber: m.lineNumber ?? null, confidence: m.confidence, matchMethod: m.matchMethod },
+          update: { status: m.status, matchedFilePath: m.matchedFilePath ?? null, scriptTestName: m.scriptTestName ?? null, lineNumber: m.lineNumber ?? null, confidence: m.confidence, matchMethod: m.matchMethod }
+        })
+      );
+    }
+    const mapped = mappings.filter((m) => m.status === "MAPPED").length;
+    const unmapped = mappings.filter((m) => m.status === "UNMAPPED").length;
+    const ambiguous = mappings.filter((m) => m.status === "AMBIGUOUS").length;
+    const coveragePercent = testCases.length > 0 ? mapped / testCases.length * 100 : 0;
+    await withTenant(
+      tenantId,
+      (tx) => tx.coverageSnapshot.create({
+        data: { tenantId, projectId, totalCases: testCases.length, mappedCases: mapped, unmappedCases: unmapped, ambiguousCases: ambiguous, coveragePercent }
+      })
+    );
+    const resolvedStyleProfile = (() => {
+      const sp = styleProfile ?? {};
+      if (framework === "selenium-java" && !sp.testStructurePattern) {
+        const hasMavenMain = treeResult.paths.some((p) => /^src\/main\/java\//.test(p));
+        if (hasMavenMain) return { ...sp, testStructurePattern: "two-tier" };
+      }
+      return sp;
+    })();
+    await withTenant(
+      tenantId,
+      (tx) => tx.gitHubRepoConnection.update({
+        where: { id: repoConnectionId },
+        data: {
+          scanStatus: "DONE",
+          detectedFramework: framework,
+          configFilePath: primary?.configPath ?? null,
+          testGlob,
+          testFileCount: testPaths.length,
+          extractedIdCount: allExtracted.length,
+          styleProfile: resolvedStyleProfile,
+          pageObjectInventory: pageObjectInventory.length > 0 ? pageObjectInventory : void 0,
+          treeSnapshot: JSON.stringify(treeResult.paths).slice(0, 1e5),
+          lastScannedAt: /* @__PURE__ */ new Date(),
+          lastSyncAt: /* @__PURE__ */ new Date()
+        }
+      })
+    );
+    try {
+      const { generateRepoSkillFiles } = await import("@taodigital/agents");
+      await generateRepoSkillFiles(tenantId, projectId, {
+        repoFullName: conn.repoFullName,
+        framework,
+        language,
+        testGlob,
+        styleProfile: resolvedStyleProfile,
+        pageObjectInventory,
+        testPaths,
+        extractedTestCount: allExtracted.length,
+        treeWasTruncated: treeResult.truncated,
+        extractedTests: allExtracted
+      });
+    } catch (e) {
+      logger.warn({ jobId, repoConnectionId, err: e?.message }, "[repo-scan] repo skill files generation failed (non-fatal)");
+    }
+    try {
+      const { alignSkillFile } = await import("@taodigital/agents");
+      await alignSkillFile(tenantId, projectId, {
+        framework,
+        language,
+        styleProfile: resolvedStyleProfile,
+        repoFullName: conn.repoFullName
+      });
+    } catch (e) {
+      logger.warn({ jobId, repoConnectionId, err: e?.message }, "[repo-scan] alignSkillFile failed (non-fatal)");
+    }
+    await updateJobProgress(tenantId, jobId, 100, `Done: ${mapped} mapped, ${unmapped} unmapped`);
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({ where: { id: jobId }, data: { status: "DONE", finishedAt: /* @__PURE__ */ new Date(), result: { testFileCount: testPaths.length, extractedIdCount: allExtracted.length, mapped, unmapped, ambiguous, coveragePercent } } })
+    );
+    aggregateJobTokens(tenantId, jobId, projectId, jobStart).catch(console.error);
+  } catch (err) {
+    const cause = err?.cause?.message ?? (typeof err?.cause === "string" ? err.cause : "");
+    const msg = `${String(err?.message ?? err)}${cause ? ` \u2014 ${cause}` : ""}`;
+    logger.error({ jobId, repoConnectionId, err: msg }, "[repo-scan] failed");
+    await withTenant(
+      tenantId,
+      (tx) => tx.gitHubRepoConnection.update({ where: { id: repoConnectionId }, data: { scanStatus: "FAILED", scanError: msg.slice(0, 500) } })
+    ).catch(() => {
+    });
+    await recordJobFailure(tenantId, jobId, err);
+  }
+}
+async function processBatchGenerateAlignedJob(jobId, config) {
+  const { tenantId, projectId, repoConnectionId, scope = "UNMAPPED", testCaseIds, force = false } = config;
+  try {
+    await updateJobProgress(tenantId, jobId, 5, "Loading repo connection");
+    const conn = await withTenant(
+      tenantId,
+      (tx) => tx.gitHubRepoConnection.findFirst({ where: { id: repoConnectionId, tenantId } })
+    );
+    if (!conn) throw new Error(`RepoConnection ${repoConnectionId} not found`);
+    const {
+      generateScriptAligned,
+      deriveRepoTargetPath,
+      validateGeneratedScript,
+      mapWithConcurrency,
+      SCRIPT_GEN_CONCURRENCY
+    } = await import("@taodigital/agents");
+    const styleProfile = conn.styleProfile;
+    const pageObjectInventory = conn.pageObjectInventory ?? [];
+    const framework = conn.detectedFramework ?? "playwright-ts";
+    const language = styleProfile?.language ?? "typescript";
+    let caseIds;
+    if (testCaseIds && testCaseIds.length > 0) {
+      caseIds = testCaseIds;
+    } else if (scope === "UNMAPPED") {
+      const mappings = await withTenant(
+        tenantId,
+        (tx) => tx.coverageMapping.findMany({
+          where: { tenantId, projectId, repoConnectionId, status: "UNMAPPED" },
+          select: { testCaseId: true }
+        })
+      );
+      caseIds = mappings.map((m) => m.testCaseId);
+    } else {
+      const cases = await withTenant(
+        tenantId,
+        (tx) => tx.testCase.findMany({
+          where: { tenantId, projectId, status: { not: "RETIRED" } },
+          select: { id: true }
+        })
+      );
+      caseIds = cases.map((c) => c.id);
+    }
+    await updateJobProgress(tenantId, jobId, 15, `Generating scripts for ${caseIds.length} test cases`);
+    let done = 0;
+    const errors = [];
+    await mapWithConcurrency(caseIds, SCRIPT_GEN_CONCURRENCY, async (tcId) => {
+      try {
+        if (!force) {
+          const existing = await withTenant(
+            tenantId,
+            (tx) => tx.testScript.findFirst({ where: { testCaseId: tcId } })
+          );
+          if (existing) {
+            done++;
+            return;
+          }
+        }
+        const tc = await withTenant(
+          tenantId,
+          (tx) => tx.testCase.findUnique({
+            where: { id: tcId },
+            select: { id: true, ref: true, title: true, screen: { select: { url: true } } }
+          })
+        );
+        const screenUrl = tc?.screen?.url ?? "";
+        const repoTargetPath = styleProfile ? deriveRepoTargetPath(screenUrl, styleProfile, framework) : deriveFallbackTargetPath(tc?.ref ?? tc?.title ?? tcId, framework);
+        const result = await generateScriptAligned({
+          tenantId,
+          projectId,
+          testCaseId: tcId,
+          styleProfile,
+          pageObjectInventory,
+          repoTargetPath,
+          save: true
+        });
+        if (result.code) {
+          const validation = await validateGeneratedScript(result.code, framework, language);
+          await withTenant(
+            tenantId,
+            (tx) => tx.testScript.updateMany({
+              where: { testCaseId: tcId },
+              data: {
+                validationStatus: validation.ok ? "PASS" : "FAIL",
+                validationErrors: validation.ok ? null : validation.errors.slice(0, 2e3)
+              }
+            })
+          );
+        }
+        done++;
+      } catch (e) {
+        errors.push(`${tcId}: ${String(e.message).slice(0, 100)}`);
+      }
+      if (done % 5 === 0) {
+        await updateJobProgress(tenantId, jobId, 15 + Math.floor(done / caseIds.length * 80), `Generated ${done}/${caseIds.length}`);
+      }
+    });
+    refreshTestScriptSkillFile(tenantId, projectId).catch(console.error);
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({
+        where: { id: jobId },
+        data: { status: "DONE", finishedAt: /* @__PURE__ */ new Date(), result: { done, errors: errors.slice(0, 20), total: caseIds.length } }
+      })
+    );
+  } catch (err) {
+    const msg = String(err?.message ?? err);
+    logger.error({ jobId, err: msg }, "[batch-generate-aligned] failed");
+    await recordJobFailure(tenantId, jobId, err);
+  }
+}
+async function processCreatePRJob(jobId, config) {
+  const { tenantId, projectId, repoConnectionId, testScriptIds, crawlJobId } = config;
+  try {
+    await updateJobProgress(tenantId, jobId, 5, "Loading connection");
+    const conn = await withTenant(
+      tenantId,
+      (tx) => tx.gitHubRepoConnection.findFirst({ where: { id: repoConnectionId, tenantId } })
+    );
+    if (!conn) throw new Error(`RepoConnection ${repoConnectionId} not found`);
+    const { decrypt: decrypt2 } = await import("@taodigital/core");
+    const token = decrypt2(conn.tokenEnc);
+    const { pushScriptsAsPR, getFileContent, mergeSpecContent } = await import("@taodigital/agents");
+    const framework = conn.detectedFramework ?? "playwright-ts";
+    let scripts;
+    if (testScriptIds && testScriptIds.length > 0) {
+      scripts = await withTenant(
+        tenantId,
+        (tx) => tx.testScript.findMany({
+          where: { id: { in: testScriptIds }, tenantId, code: { not: null } },
+          include: { testCase: { select: { title: true, ref: true, repoTargetPath: true } } }
+        })
+      );
+    } else {
+      scripts = await withTenant(
+        tenantId,
+        (tx) => tx.testScript.findMany({
+          where: { tenantId, projectId, pushedToPR: false, validationStatus: { in: ["PASS", "PENDING"] }, code: { not: null } },
+          include: { testCase: { select: { title: true, ref: true, repoTargetPath: true } } }
+        })
+      );
+    }
+    if (scripts.length === 0) throw new Error("No generated scripts found to push.");
+    const files = await Promise.all(scripts.map(async (s) => {
+      const path2 = s.testCase?.repoTargetPath ?? deriveFallbackTargetPath(s.testCase?.ref ?? s.testCase?.title ?? s.id, framework);
+      let content = s.code;
+      const isSpecFile = /\.(spec|test|cy)\.(ts|js|py|java)$/.test(path2) || /_test\.py$/.test(path2);
+      if (isSpecFile) {
+        const existing = await getFileContent(token, conn.repoFullName, path2, conn.defaultBranch).catch(() => null);
+        if (existing && existing.trim().length > 0) {
+          logger.info({ path: path2 }, "[create-pr] merging new tests into existing spec file");
+          content = mergeSpecContent(existing, s.code);
+        }
+      }
+      return { path: path2, content };
+    }));
+    if (files.length === 0) throw new Error("No scripts to push.");
+    await updateJobProgress(tenantId, jobId, 20, `Pushing ${files.length} scripts to GitHub`);
+    const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const branchName = `zeta/new-coverage-${now}-${jobId.slice(0, 8)}`;
+    const prBody = buildPRBody(scripts, projectId);
+    const prResult = await pushScriptsAsPR({
+      token,
+      repo: conn.repoFullName,
+      baseBranch: conn.defaultBranch,
+      branchName,
+      files,
+      prTitle: `ZeTa: Add test coverage for ${files.length} new scenario${files.length === 1 ? "" : "s"}`,
+      prBody,
+      draft: false
+    });
+    const pr = await withTenant(
+      tenantId,
+      (tx) => tx.gitHubPR.create({
+        data: {
+          tenantId,
+          projectId,
+          repoConnectionId,
+          prNumber: prResult.prNumber,
+          prUrl: prResult.prUrl,
+          branch: prResult.branch,
+          headSha: prResult.headSha,
+          status: "OPEN",
+          crawlJobId: crawlJobId ?? null,
+          scriptCount: files.length,
+          prBody: prBody.slice(0, 1e4)
+        }
+      })
+    );
+    const scriptIds = scripts.map((s) => s.id);
+    await withTenant(
+      tenantId,
+      (tx) => tx.testScript.updateMany({
+        where: { id: { in: scriptIds } },
+        data: { pushedToPR: true, pushedPRId: pr.id }
+      })
+    );
+    await notifyAdmins(tenantId, {
+      type: "GITHUB_PR_CREATED",
+      title: "ZeTa created a GitHub PR",
+      body: `${files.length} new test script${files.length === 1 ? "" : "s"} pushed. PR #${prResult.prNumber}: ${prResult.prUrl}`,
+      metadata: { prUrl: prResult.prUrl, prNumber: prResult.prNumber, scriptCount: files.length }
+    });
+    await updateJobProgress(tenantId, jobId, 100, `PR #${prResult.prNumber} created`);
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({
+        where: { id: jobId },
+        data: { status: "DONE", finishedAt: /* @__PURE__ */ new Date(), result: { prUrl: prResult.prUrl, prNumber: prResult.prNumber, scriptCount: files.length } }
+      })
+    );
+  } catch (err) {
+    const msg = String(err?.message ?? err);
+    logger.error({ jobId, err: msg }, "[create-pr] failed");
+    await recordJobFailure(tenantId, jobId, err);
+  }
+}
+function buildPRBody(scripts, projectId) {
+  const lines = [
+    "## ZeTa \u2014 Automated Test Coverage",
+    "",
+    `Generated by ZeTa Quality Intelligence Platform for project \`${projectId}\`.`,
+    "",
+    "### Scripts Added",
+    "",
+    "| Test Case | Target Path |",
+    "|---|---|"
+  ];
+  for (const s of scripts.slice(0, 30)) {
+    const title = s.testCase?.title ?? s.id;
+    const path2 = s.testCase?.repoTargetPath ?? "(unknown)";
+    lines.push(`| ${title.replace(/\|/g, "\\|").slice(0, 60)} | \`${path2}\` |`);
+  }
+  if (scripts.length > 30) lines.push(`| ... and ${scripts.length - 30} more | |`);
+  lines.push("", "---", "_Review each test carefully before merging. ZeTa generates scripts aligned to your existing framework conventions._");
+  return lines.join("\n");
+}
+function generateK6Script(params) {
+  const { endpoints, baseUrl, vus = 10, duration = "30s", thinkTimeSeconds = 1 } = params;
+  const checks = endpoints.filter((ep) => ["GET", "POST", "PUT", "PATCH", "DELETE"].includes(ep.method.toUpperCase())).map((ep) => {
+    const method = ep.method.toUpperCase();
+    const url = `\${__ENV.BASE_URL || '${baseUrl}'}${ep.path}`;
+    const checkKey = `${method} ${ep.path} is 2xx`;
+    const callExpr = method === "GET" || method === "DELETE" ? `http.${method.toLowerCase()}(\`${url}\`, params)` : `http.${method.toLowerCase()}(\`${url}\`, JSON.stringify({}), params)`;
+    return `
+  // ${ep.summary ?? `${method} ${ep.path}`}
+  {
+    const res = ${callExpr};
+    check(res, { '${checkKey}': (r) => r.status >= 200 && r.status < 300 });
+    errorRate.add(res.status >= 400);
+  }`;
+  }).join("\n");
+  return `import http from 'k6/http';
+import { check, sleep } from 'k6';
+import { Rate } from 'k6/metrics';
+
+const errorRate = new Rate('errors');
+
+export const options = {
+  vus: ${vus},
+  duration: '${duration}',
+  thresholds: {
+    http_req_duration: ['p(95)<2000'],
+    errors: ['rate<0.1'],
+  },
+};
+
+const params = {
+  headers: { 'Content-Type': 'application/json' },
+};
+
+export default function () {
+${checks}
+  sleep(${thinkTimeSeconds});
+}
+`;
+}
+async function processNewPagesPipelineJob(jobId, config) {
+  const { tenantId, projectId, crawlJobId: _crawlJobId, repoConnectionId, autoPR = false } = config;
+  try {
+    await updateJobProgress(tenantId, jobId, 5, "Detecting new screens");
+    const conn = await withTenant(
+      tenantId,
+      (tx) => tx.gitHubRepoConnection.findFirst({
+        where: repoConnectionId ? { id: repoConnectionId, tenantId } : { tenantId, projectId, status: "ACTIVE" }
+      })
+    );
+    const sinceDate = conn?.lastSyncAt ?? /* @__PURE__ */ new Date(0);
+    const newScreens = await withTenant(
+      tenantId,
+      (tx) => tx.screen.findMany({
+        where: {
+          tenantId,
+          projectId,
+          lastSeenAt: { gt: sinceDate },
+          status: { not: "DELETED" }
+        },
+        select: { id: true, url: true, name: true },
+        take: 100
+      })
+    );
+    if (newScreens.length === 0) {
+      await updateJobProgress(tenantId, jobId, 100, "No new screens to process");
+      await withTenant(
+        tenantId,
+        (tx) => tx.platformJob.update({ where: { id: jobId }, data: { status: "DONE", finishedAt: /* @__PURE__ */ new Date(), result: { newScreens: 0 } } })
+      );
+      return;
+    }
+    await updateJobProgress(tenantId, jobId, 15, `Found ${newScreens.length} new screens`);
+    const generationJobs = [];
+    for (const screen of newScreens) {
+      const caseCount = await withTenant(
+        tenantId,
+        (tx) => tx.testCase.count({ where: { tenantId, screenId: screen.id } })
+      );
+      if (caseCount === 0) {
+        const jid = await enqueueJob("GENERATE_SCREEN_TESTS", {
+          tenantId,
+          projectId,
+          screenId: screen.id,
+          triggerAlignedScripts: conn != null,
+          repoConnectionId: conn?.id ?? null
+        });
+        generationJobs.push(jid);
+      }
+    }
+    await updateJobProgress(tenantId, jobId, 60, `Queued ${generationJobs.length} test generation jobs`);
+    if (conn && autoPR) {
+      await enqueueJob("BATCH_GENERATE_ALIGNED", {
+        tenantId,
+        projectId,
+        repoConnectionId: conn.id,
+        scope: "UNMAPPED"
+      });
+    }
+    await withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({
+        where: { id: jobId },
+        data: { status: "DONE", finishedAt: /* @__PURE__ */ new Date(), result: { newScreens: newScreens.length, generationJobs: generationJobs.length } }
+      })
+    );
+  } catch (err) {
+    const msg = String(err?.message ?? err);
+    logger.error({ jobId, err: msg }, "[new-pages-pipeline] failed");
+    await recordJobFailure(tenantId, jobId, err);
+  }
+}
+export {
+  FailureType,
+  aggregateJobTokens,
+  cancelJob,
+  claimNextQueuedJob,
+  claimSpecificJob,
+  classifyFailure,
+  createTrackedJob,
+  dispatchClaimedJob,
+  enqueueJob,
+  finishTrackedJob,
+  generateK6Script,
+  generateTOTP,
+  getActiveExecutionCount,
+  getJob,
+  listJobs,
+  processDataRetentionPurge,
+  processJob,
+  promoteToDeadLetterQueue,
+  recordJobFailure,
+  requeueOrphanedJobs,
+  requeueStaleRunningJobs,
+  rerunJob,
+  resumeJob,
+  retryEligibleFailedJobs,
+  startJobWorkerLoop,
+  stopJobWorkerLoop,
+  updateJobProgress
+};
+//# sourceMappingURL=job-queue.js.map