@detiq/crawler 1.1.26 → 1.1.27

package/dist/job-queue.js

@@ -1,36 +1,15 @@
-import crypto from "node:crypto";
 import { withTenant, prismaAdmin } from "@detiq/database";
 import { crawlJobsTotal, crawlJobDurationSeconds } from "@detiq/core";
 import { logger } from "./logger.js";
+import { AppBrain, buildArtifactKey, getTenantStorageConfig, uploadScreenshotToTenantStorage, uploadFileToTenantStorage, notifyRunCompletion, recordLLMCall, downloadBufferFromTenantStorage, dispatchToTenantAdmins } from "@detiq/app-brain";
 async function notifyAdmins(tenantId, data) {
   try {
-    const members = await withTenant(
-      tenantId,
-      (tx) => tx.membership.findMany({
-        where: { tenantId, role: { in: ["OWNER", "ADMIN"] } },
-        select: { userId: true }
-      })
-    );
-    await withTenant(
-      tenantId,
-      (tx) => tx.notification.createMany({
-        data: members.map((m) => ({
-          id: `notif_${crypto.randomUUID()}`,
-          tenantId,
-          userId: m.userId,
-          type: data.type,
-          title: data.title,
-          body: data.body,
-          metadata: data.metadata
-        }))
-      })
-    );
+    await dispatchToTenantAdmins(tenantId, data);
   } catch (e) {
     console.error("[notify] failed:", e);
   }
 }
-import { AppBrain, buildArtifactKey, getTenantStorageConfig, uploadScreenshotToTenantStorage, uploadFileToTenantStorage, notifyRunCompletion, recordLLMCall } from "@detiq/app-brain";
-import { generateTaxonomySkillFiles, groupScreensWithAI, generateExecutionPlan, refreshTestCasesSkillFile, refreshTestDataSkillFile, refreshTestScriptSkillFile, refreshRequirementsCoverageSkillFile, refreshTestExecutionHistorySkillFile, refreshVisualRegressionHistorySkillFile, refreshLocatorStrategyWithHealingData, refreshFieldCatalogSkillFile, detectFieldsFromHtml, mergeIntoCatalog } from "@detiq/agents";
+import { generateTaxonomySkillFiles, groupScreensWithAI, generateExecutionPlan, refreshTestCasesSkillFile, refreshTestDataSkillFile, refreshTestScriptSkillFile, refreshRequirementsCoverageSkillFile, refreshTestExecutionHistorySkillFile, refreshVisualRegressionHistorySkillFile, refreshLocatorStrategyWithHealingData, refreshFieldCatalogSkillFile, detectFieldsFromHtml, mergeIntoCatalog, generateArtifactIntelligence } from "@detiq/agents";
 import { crawlProject, domFallbackElements } from "./crawler.js";
 import { httpCrawl } from "./http-engine.js";
 import { hashContent, normalizeText } from "./incremental-diff.js";
@@ -44,6 +23,38 @@ import { createHmac } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 import os from "node:os";
+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);
+}
 function generateTOTP(secret) {
   const BASE32 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
   const clean = secret.toUpperCase().replace(/\s/g, "").replace(/=/g, "");
@@ -83,8 +94,19 @@ function makeJobName(type) {
 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;
@@ -94,6 +116,7 @@ async function claimSpecificJob(jobId) {
     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;
@@ -104,13 +127,20 @@ async function claimNextQueuedJob() {
     UPDATE "PlatformJob"
     SET status = 'RUNNING', "startedAt" = NOW(), "heartbeatAt" = NOW(), "workerId" = ${WORKER_ID}
     WHERE id = (
-      SELECT id FROM "PlatformJob"
+      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}
         )
-      ORDER BY "queuedAt" ASC
+        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
     )
@@ -192,40 +222,72 @@ async function dispatchClaimedJob(job) {
     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");
+    const errorMessage = String(err?.message ?? err);
+    const failureType = classifyFailure(err);
+    const jobRow = await prismaAdmin.platformJob.findUnique({ where: { id: job.id }, select: { retryCount: true, result: true } }).catch(() => null);
+    const currentRetry = jobRow?.retryCount ?? 0;
+    const nextRetryAt = computeNextRetryAt(failureType, currentRetry);
     await prismaAdmin.platformJob.update({
       where: { id: job.id },
-      data: { status: "FAILED", error: String(err?.message ?? err), finishedAt: /* @__PURE__ */ new Date(), nextRetryAt: new Date(Date.now() + 6e4) }
+      data: {
+        status: nextRetryAt ? "RETRY_WAIT" : "FAILED",
+        error: errorMessage,
+        finishedAt: /* @__PURE__ */ new Date(),
+        heartbeatAt: null,
+        workerId: null,
+        nextRetryAt,
+        retryCount: { increment: 1 },
+        failureType,
+        // Store failureType in result JSON for observability (backward compat)
+        result: { ...jobRow?.result ?? {}, failureType }
+      }
     }).catch(() => {
     });
+    if (!nextRetryAt || failureType === "FATAL" /* FATAL */) {
+      await prismaAdmin.platformJob.update({
+        where: { id: job.id },
+        data: { dlq: true, dlqAt: /* @__PURE__ */ new Date(), dlqReason: errorMessage }
+      }).catch(() => {
+      });
+    }
   }
 }
 let workerLoopTimer = null;
+let workerShuttingDown = false;
 async function retryEligibleFailedJobs() {
   const rows = await prismaAdmin.$queryRaw`
     UPDATE "PlatformJob"
-    SET status = 'QUEUED',
+    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" <= NOW()
-      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
+      AND "nextRetryAt" IS NULL
+      AND "retryCount" < 5
     RETURNING id
   `;
   if (rows.length > 0) {
-    logger.info({ jobIds: rows.map((r) => r.id) }, "[job-worker] requeued failed job(s) for retry");
+    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()
+      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
@@ -246,7 +308,7 @@ function startJobWorkerLoop(opts) {
   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 tick = async () => {
+  const sweepTick = async () => {
     try {
       await retryEligibleFailedJobs();
       await promoteToDeadLetterQueue();
@@ -254,28 +316,46 @@ function startJobWorkerLoop(opts) {
     } catch (err) {
       logger.error({ err: String(err) }, "[job-worker] stale/retry job sweep failed");
     }
-    try {
-      const pauseRow = await prismaAdmin.systemConfig.findUnique({ where: { key: "queue.paused" } });
-      if (pauseRow?.value === "true") {
+  };
+  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");
-      } else {
-        for (let i = 0; i < concurrency; i++) {
-          const job = await claimNextQueuedJob();
-          if (!job) break;
-          void dispatchClaimedJob(job);
-        }
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+        continue;
       }
-    } catch (err) {
-      logger.error({ err: String(err) }, "[job-worker] claim loop failed");
+      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");
+      });
     }
   };
-  workerLoopTimer = setInterval(tick, pollIntervalMs);
-  requeueOrphanedJobs().catch(
-    (err) => logger.error({ err: String(err) }, "[job-worker] startup orphan sweep failed")
-  );
-  void tick();
+  void pollLoop();
 }
 function stopJobWorkerLoop() {
+  workerShuttingDown = true;
   if (workerLoopTimer) clearInterval(workerLoopTimer);
   workerLoopTimer = null;
 }
@@ -284,28 +364,50 @@ async function createTrackedJob(type, config) {
   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(), config }
+      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) {
-  const nextRetryAt = error ? new Date(Date.now() + 6e4) : void 0;
+  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: error ? "FAILED" : "DONE",
+        status: nextRetryAt ? "RETRY_WAIT" : "FAILED",
         finishedAt: /* @__PURE__ */ new Date(),
-        ...error ? { error, nextRetryAt } : { progress: 100 }
+        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 } = config;
+  const { tenantId, projectId, submittedBy } = config;
   const name = makeJobName(type);
   const job = await withTenant(
     tenantId,
@@ -316,7 +418,8 @@ async function enqueueJob(type, config) {
         type,
         name,
         status: "QUEUED",
-        config
+        config,
+        ...submittedBy ? { submittedBy } : {}
       }
     })
   );
@@ -364,7 +467,7 @@ async function cancelJob(tenantId, jobId) {
     tenantId,
     (tx) => tx.platformJob.update({
       where: { id: jobId },
-      data: { status: "CANCELLED", finishedAt: /* @__PURE__ */ new Date(), heartbeatAt: null, workerId: null }
+      data: { status: "CANCEL_REQUESTED" }
     })
   );
 }
@@ -403,14 +506,15 @@ async function updateJobProgress(tenantId, jobId, progress, step) {
         where: { id: jobId },
         select: { status: true }
       });
-      if (current?.status === "CANCELLED") {
+      if (current?.status === "CANCELLED" || current?.status === "CANCEL_REQUESTED") {
         runningControllers.get(jobId)?.abort();
         runningControllers.delete(jobId);
         return;
       }
       await tx.platformJob.update({
         where: { id: jobId },
-        data: { progress, result: { step }, heartbeatAt: /* @__PURE__ */ new Date() }
+        // 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 {
@@ -423,7 +527,7 @@ async function heartbeatJob(tenantId, jobId) {
         where: { id: jobId },
         select: { status: true }
       });
-      if (current?.status === "CANCELLED") {
+      if (current?.status === "CANCELLED" || current?.status === "CANCEL_REQUESTED") {
         runningControllers.get(jobId)?.abort();
         runningControllers.delete(jobId);
         return;
@@ -533,6 +637,19 @@ async function processJob(jobId, config, opts) {
       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);
@@ -1170,7 +1287,7 @@ Each test case must reference its reqRef (the requirement ID like REQ-001).`;
 ${reqBlock}`;
     let parsed = { cases: [] };
     try {
-      const reqSeed = deterministicSeed(`${tenantId}:${projectId}:req-cases:${reqs.map((r) => r.reqId).sort().join("|").slice(0, 300)}`);
+      const reqSeed = deterministicSeed(`req-cases:${reqs.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(() => {
       });
@@ -1436,6 +1553,18 @@ async function processDataRetentionPurge() {
     }
   });
   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;
@@ -2448,7 +2577,110 @@ async function processGenerateScriptJob(jobId, config) {
     await finishTrackedJob(tenantId, jobId, e?.message ?? "generate-script failed");
   }
 }
+function queueImportedArtifactSkillRefresh(tenantId, projectId, reason) {
+  setImmediate(() => {
+    import("@detiq/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 withTenant(
+      tenantId,
+      (tx) => tx.platformJob.update({ where: { id: jobId }, data: { status: "FAILED", finishedAt: /* @__PURE__ */ new Date(), error: msg.slice(0, 1e3) } })
+    ).catch(() => {
+    });
+    queueImportedArtifactSkillRefresh(tenantId, projectId, "artifact-intel-failed");
+  }
+}
 jobDispatchTable = {
+  ARTIFACT_INTEL: processArtifactIntelJob,
   CRAWL: processJob,
   CAPTURE_STEPS: processCaptureStepsJob,
   DISCOVER: processDiscoverJob,
@@ -3280,15 +3512,18 @@ async function processNewPagesPipelineJob(jobId, config) {
   }
 }
 export {
+  FailureType,
   aggregateJobTokens,
   cancelJob,
   claimNextQueuedJob,
   claimSpecificJob,
+  classifyFailure,
   createTrackedJob,
   dispatchClaimedJob,
   enqueueJob,
   finishTrackedJob,
   generateTOTP,
+  getActiveExecutionCount,
   getJob,
   listJobs,
   processDataRetentionPurge,