@kaikybrofc/omnizap-system 2.2.10 → 2.3.1

package/app/modules/stickerPackModule/stickerClassificationBackgroundRuntime.js

@@ -5,22 +5,9 @@ import logger from '../../utils/logger/loggerModule.js';
 import { recordStickerClassificationCycle, setQueueDepth } from '../../observability/metrics.js';
 import { listStickerAssetsPendingClassification, findStickerAssetById } from './stickerAssetRepository.js';
 import { classifierConfig, ensureStickerAssetClassified } from './stickerClassificationService.js';
-import {
-  listAssetsForPrioritySignalBackfillReprocess,
-  listAssetsForLowConfidenceReprocess,
-  listAssetsForModelUpgradeReprocess,
-} from './stickerAssetClassificationRepository.js';
-import {
-  claimStickerAssetReprocessTask,
-  completeStickerAssetReprocessTask,
-  countStickerAssetReprocessQueueByStatus,
-  enqueueStickerAssetReprocess,
-  failStickerAssetReprocessTask,
-} from './stickerAssetReprocessQueueRepository.js';
-import {
-  batchReprocess as runDeterministicSemanticReclassification,
-  deterministicReclassificationConfig,
-} from './semanticReclassificationEngine.js';
+import { listAssetsForPrioritySignalBackfillReprocess, listAssetsForLowConfidenceReprocess, listAssetsForModelUpgradeReprocess } from './stickerAssetClassificationRepository.js';
+import { claimStickerAssetReprocessTask, completeStickerAssetReprocessTask, countStickerAssetReprocessQueueByStatus, enqueueStickerAssetReprocess, failStickerAssetReprocessTask } from './stickerAssetReprocessQueueRepository.js';
+import { batchReprocess as runDeterministicSemanticReclassification, deterministicReclassificationConfig } from './semanticReclassificationEngine.js';
 
 const parseEnvBool = (value, fallback) => {
   if (value === undefined || value === null || value === '') return fallback;
@@ -37,58 +24,26 @@ const INTERVAL_MIN_MS_RAW = Number(process.env.STICKER_CLASSIFICATION_BACKGROUND
 const INTERVAL_MAX_MS_RAW = Number(process.env.STICKER_CLASSIFICATION_BACKGROUND_INTERVAL_MAX_MS);
 const DEFAULT_INTERVAL_MIN_MS = 5 * 60_000;
 const DEFAULT_INTERVAL_MAX_MS = 10 * 60_000;
-const INTERVAL_MIN_MS = Number.isFinite(INTERVAL_MIN_MS_RAW)
-  ? Math.max(60_000, Math.min(3_600_000, INTERVAL_MIN_MS_RAW))
-  : DEFAULT_INTERVAL_MIN_MS;
-const INTERVAL_MAX_MS_FROM_ENV = Number.isFinite(INTERVAL_MAX_MS_RAW)
-  ? Math.max(60_000, Math.min(3_600_000, INTERVAL_MAX_MS_RAW))
-  : DEFAULT_INTERVAL_MAX_MS;
+const INTERVAL_MIN_MS = Number.isFinite(INTERVAL_MIN_MS_RAW) ? Math.max(60_000, Math.min(3_600_000, INTERVAL_MIN_MS_RAW)) : DEFAULT_INTERVAL_MIN_MS;
+const INTERVAL_MAX_MS_FROM_ENV = Number.isFinite(INTERVAL_MAX_MS_RAW) ? Math.max(60_000, Math.min(3_600_000, INTERVAL_MAX_MS_RAW)) : DEFAULT_INTERVAL_MAX_MS;
 const INTERVAL_MAX_MS = Math.max(INTERVAL_MIN_MS, INTERVAL_MAX_MS_FROM_ENV);
-const LEGACY_FIXED_INTERVAL_MS = Number.isFinite(LEGACY_INTERVAL_MS) && LEGACY_INTERVAL_MS > 0
-  ? Math.max(60_000, Math.min(3_600_000, LEGACY_INTERVAL_MS))
-  : null;
+const LEGACY_FIXED_INTERVAL_MS = Number.isFinite(LEGACY_INTERVAL_MS) && LEGACY_INTERVAL_MS > 0 ? Math.max(60_000, Math.min(3_600_000, LEGACY_INTERVAL_MS)) : null;
 const EFFECTIVE_INTERVAL_MIN_MS = LEGACY_FIXED_INTERVAL_MS || INTERVAL_MIN_MS;
 const EFFECTIVE_INTERVAL_MAX_MS = LEGACY_FIXED_INTERVAL_MS || INTERVAL_MAX_MS;
 const cpuCount = Math.max(1, Number(os.cpus()?.length || 1));
-const BACKGROUND_CONCURRENCY = Math.max(
-  1,
-  Math.min(16, Number(process.env.STICKER_CLASSIFICATION_BACKGROUND_CONCURRENCY) || cpuCount),
-);
-const BATCH_SIZE = Math.max(
-  1,
-  Math.min(300, Number(process.env.STICKER_CLASSIFICATION_BACKGROUND_BATCH_SIZE) || BACKGROUND_CONCURRENCY * 2),
-);
+const BACKGROUND_CONCURRENCY = Math.max(1, Math.min(16, Number(process.env.STICKER_CLASSIFICATION_BACKGROUND_CONCURRENCY) || cpuCount));
+const BATCH_SIZE = Math.max(1, Math.min(300, Number(process.env.STICKER_CLASSIFICATION_BACKGROUND_BATCH_SIZE) || BACKGROUND_CONCURRENCY * 2));
 
 const REPROCESS_ENABLED = parseEnvBool(process.env.STICKER_REPROCESS_QUEUE_ENABLED, true);
 const REPROCESS_MAX_PER_CYCLE = Math.max(0, Math.min(300, Number(process.env.STICKER_REPROCESS_MAX_PER_CYCLE) || BATCH_SIZE));
-const REPROCESS_MODEL_UPGRADE_SCAN_LIMIT = Math.max(
-  0,
-  Math.min(2000, Number(process.env.STICKER_REPROCESS_MODEL_UPGRADE_SCAN_LIMIT) || 350),
-);
-const REPROCESS_LOW_CONFIDENCE_SCAN_LIMIT = Math.max(
-  0,
-  Math.min(2000, Number(process.env.STICKER_REPROCESS_LOW_CONFIDENCE_SCAN_LIMIT) || 250),
-);
-const REPROCESS_LOW_CONFIDENCE_THRESHOLD = Number.isFinite(Number(process.env.STICKER_REPROCESS_LOW_CONFIDENCE_THRESHOLD))
-  ? Number(process.env.STICKER_REPROCESS_LOW_CONFIDENCE_THRESHOLD)
-  : 0.65;
-const REPROCESS_LOW_CONFIDENCE_STALE_HOURS = Math.max(
-  1,
-  Math.min(24 * 365, Number(process.env.STICKER_REPROCESS_LOW_CONFIDENCE_STALE_HOURS) || 48),
-);
+const REPROCESS_MODEL_UPGRADE_SCAN_LIMIT = Math.max(0, Math.min(2000, Number(process.env.STICKER_REPROCESS_MODEL_UPGRADE_SCAN_LIMIT) || 350));
+const REPROCESS_LOW_CONFIDENCE_SCAN_LIMIT = Math.max(0, Math.min(2000, Number(process.env.STICKER_REPROCESS_LOW_CONFIDENCE_SCAN_LIMIT) || 250));
+const REPROCESS_LOW_CONFIDENCE_THRESHOLD = Number.isFinite(Number(process.env.STICKER_REPROCESS_LOW_CONFIDENCE_THRESHOLD)) ? Number(process.env.STICKER_REPROCESS_LOW_CONFIDENCE_THRESHOLD) : 0.65;
+const REPROCESS_LOW_CONFIDENCE_STALE_HOURS = Math.max(1, Math.min(24 * 365, Number(process.env.STICKER_REPROCESS_LOW_CONFIDENCE_STALE_HOURS) || 48));
 const REPROCESS_PRIORITY_BACKFILL_ENABLED = parseEnvBool(process.env.STICKER_REPROCESS_PRIORITY_BACKFILL_ENABLED, true);
-const REPROCESS_PRIORITY_BACKFILL_SCAN_LIMIT = Math.max(
-  0,
-  Math.min(3000, Number(process.env.STICKER_REPROCESS_PRIORITY_BACKFILL_SCAN_LIMIT) || 300),
-);
-const REPROCESS_PRIORITY_BACKFILL_PRIORITY = Math.max(
-  1,
-  Math.min(100, Number(process.env.STICKER_REPROCESS_PRIORITY_BACKFILL_PRIORITY) || 95),
-);
-const REPROCESS_RETRY_DELAY_SECONDS = Math.max(
-  5,
-  Math.min(3600, Number(process.env.STICKER_REPROCESS_RETRY_DELAY_SECONDS) || 120),
-);
+const REPROCESS_PRIORITY_BACKFILL_SCAN_LIMIT = Math.max(0, Math.min(3000, Number(process.env.STICKER_REPROCESS_PRIORITY_BACKFILL_SCAN_LIMIT) || 300));
+const REPROCESS_PRIORITY_BACKFILL_PRIORITY = Math.max(1, Math.min(100, Number(process.env.STICKER_REPROCESS_PRIORITY_BACKFILL_PRIORITY) || 95));
+const REPROCESS_RETRY_DELAY_SECONDS = Math.max(5, Math.min(3600, Number(process.env.STICKER_REPROCESS_RETRY_DELAY_SECONDS) || 120));
 
 let cycleHandle = null;
 let startupTimeoutHandle = null;
@@ -306,10 +261,7 @@ const processReprocessQueue = async ({ limit = REPROCESS_MAX_PER_CYCLE } = {}) =
   }
 
   try {
-    const [pendingDepth, processingDepth] = await Promise.all([
-      countStickerAssetReprocessQueueByStatus('pending'),
-      countStickerAssetReprocessQueueByStatus('processing'),
-    ]);
+    const [pendingDepth, processingDepth] = await Promise.all([countStickerAssetReprocessQueueByStatus('pending'), countStickerAssetReprocessQueueByStatus('processing')]);
     setQueueDepth('sticker_reprocess_pending', pendingDepth);
     setQueueDepth('sticker_reprocess_processing', processingDepth);
   } catch (error) {
@@ -346,11 +298,7 @@ const processDeterministicReclassification = async () => {
   });
 };
 
-export const runStickerClassificationCycle = async ({
-  processPending = true,
-  processReprocess = true,
-  processDeterministic = true,
-} = {}) => {
+export const runStickerClassificationCycle = async ({ processPending = true, processReprocess = true, processDeterministic = true } = {}) => {
   const startedAt = Date.now();
   const shouldProcessClassifier = classifierConfig.enabled;
   const shouldProcessDeterministic = deterministicReclassificationConfig.enabled;
@@ -372,22 +320,11 @@ export const runStickerClassificationCycle = async ({
   try {
     const reprocessStats = processReprocess && shouldProcessClassifier ? await processReprocessQueue() : null;
     const pendingStats = processPending && shouldProcessClassifier ? await processPendingAssets() : null;
-    const deterministicStats = processDeterministic
-      ? await processDeterministicReclassification()
-      : null;
-
-    const processed =
-      Number(pendingStats?.processed || 0)
-      + Number(reprocessStats?.processed || 0)
-      + Number(deterministicStats?.processed || 0);
-    const classified =
-      Number(pendingStats?.classified || 0)
-      + Number(reprocessStats?.classified || 0)
-      + Number(deterministicStats?.updated || 0);
-    const failed =
-      Number(pendingStats?.failed || 0)
-      + Number(reprocessStats?.failed || 0)
-      + Number(deterministicStats?.failed || 0);
+    const deterministicStats = processDeterministic ? await processDeterministicReclassification() : null;
+
+    const processed = Number(pendingStats?.processed || 0) + Number(reprocessStats?.processed || 0) + Number(deterministicStats?.processed || 0);
+    const classified = Number(pendingStats?.classified || 0) + Number(reprocessStats?.classified || 0) + Number(deterministicStats?.updated || 0);
+    const failed = Number(pendingStats?.failed || 0) + Number(reprocessStats?.failed || 0) + Number(deterministicStats?.failed || 0);
     const durationMs = Date.now() - startedAt;
 
     recordStickerClassificationCycle({
@@ -428,8 +365,7 @@ const resolveNextCycleDelayMs = () => {
     return EFFECTIVE_INTERVAL_MIN_MS;
   }
 
-  return EFFECTIVE_INTERVAL_MIN_MS
-    + Math.floor(Math.random() * (EFFECTIVE_INTERVAL_MAX_MS - EFFECTIVE_INTERVAL_MIN_MS + 1));
+  return EFFECTIVE_INTERVAL_MIN_MS + Math.floor(Math.random() * (EFFECTIVE_INTERVAL_MAX_MS - EFFECTIVE_INTERVAL_MIN_MS + 1));
 };
 
 const scheduleNextCycle = () => {
@@ -500,27 +436,12 @@ const classifyBatch = async () => {
       affinity_threshold: deterministicReclassificationConfig.affinity_threshold,
     };
 
-    const processed =
-      Number(pending.processed || 0)
-      + Number(reprocess.processed || 0)
-      + Number(deterministic.processed || 0);
-    const classified =
-      Number(pending.classified || 0)
-      + Number(reprocess.classified || 0)
-      + Number(deterministic.updated || 0);
-    const failed =
-      Number(pending.failed || 0)
-      + Number(reprocess.failed || 0)
-      + Number(deterministic.failed || 0);
+    const processed = Number(pending.processed || 0) + Number(reprocess.processed || 0) + Number(deterministic.processed || 0);
+    const classified = Number(pending.classified || 0) + Number(reprocess.classified || 0) + Number(deterministic.updated || 0);
+    const failed = Number(pending.failed || 0) + Number(reprocess.failed || 0) + Number(deterministic.failed || 0);
     const gainCount = classified;
 
-    if (
-      processed > 0
-      || reprocess.enqueued_priority_backfill > 0
-      || reprocess.enqueued_model_upgrade > 0
-      || reprocess.enqueued_low_confidence > 0
-      || deterministic.updated > 0
-    ) {
+    if (processed > 0 || reprocess.enqueued_priority_backfill > 0 || reprocess.enqueued_model_upgrade > 0 || reprocess.enqueued_low_confidence > 0 || deterministic.updated > 0) {
       logger.info('Worker de classificação executado.', {
         action: 'sticker_classification_background_cycle',
         processed,

package/app/modules/stickerPackModule/stickerClassificationService.js

@@ -1,9 +1,5 @@
 import logger from '../../utils/logger/loggerModule.js';
-import {
-  findStickerClassificationByAssetId,
-  listStickerClassificationsByAssetIds,
-  upsertStickerAssetClassification,
-} from './stickerAssetClassificationRepository.js';
+import { findStickerClassificationByAssetId, listStickerClassificationsByAssetIds, upsertStickerAssetClassification } from './stickerAssetClassificationRepository.js';
 import { enqueueSemanticClusterResolution } from './semanticThemeClusterService.js';
 
 const parseEnvBool = (value, fallback) => {
@@ -15,26 +11,14 @@ const parseEnvBool = (value, fallback) => {
 };
 
 const CLIP_CLASSIFIER_ENABLED = parseEnvBool(process.env.CLIP_CLASSIFIER_ENABLED, true);
-const CLIP_CLASSIFIER_API_URL =
-  String(process.env.CLIP_CLASSIFIER_API_URL || 'http://127.0.0.1:8008/classify').trim() ||
-  'http://127.0.0.1:8008/classify';
-const CLIP_CLASSIFIER_FEEDBACK_API_URL = String(
-  process.env.CLIP_CLASSIFIER_FEEDBACK_API_URL
-  || CLIP_CLASSIFIER_API_URL.replace(/\/classify\/?$/i, '/feedback'),
-).trim();
+const CLIP_CLASSIFIER_API_URL = String(process.env.CLIP_CLASSIFIER_API_URL || 'http://127.0.0.1:8008/classify').trim() || 'http://127.0.0.1:8008/classify';
+const CLIP_CLASSIFIER_FEEDBACK_API_URL = String(process.env.CLIP_CLASSIFIER_FEEDBACK_API_URL || CLIP_CLASSIFIER_API_URL.replace(/\/classify\/?$/i, '/feedback')).trim();
 const CLIP_CLASSIFIER_TIMEOUT_MS = Math.max(500, Number(process.env.CLIP_CLASSIFIER_TIMEOUT_MS) || 3000);
 const CLIP_CLASSIFIER_PROVIDER = String(process.env.CLIP_CLASSIFIER_PROVIDER || 'clip').trim() || 'clip';
-const CLIP_CLASSIFIER_CLASSIFICATION_VERSION =
-  String(process.env.CLIP_CLASSIFIER_CLASSIFICATION_VERSION || process.env.CLIP_CLASSIFIER_MODEL_VERSION || 'v1').trim() || 'v1';
-const CLIP_CLASSIFIER_NSFW_THRESHOLD = Number.isFinite(Number(process.env.CLIP_CLASSIFIER_NSFW_THRESHOLD))
-  ? Number(process.env.CLIP_CLASSIFIER_NSFW_THRESHOLD)
-  : null;
-const STICKER_TAG_MIN_SCORE = Number.isFinite(Number(process.env.STICKER_CLASSIFICATION_TAG_MIN_SCORE))
-  ? Number(process.env.STICKER_CLASSIFICATION_TAG_MIN_SCORE)
-  : 0.2;
-const PACK_TAG_MIN_SCORE = Number.isFinite(Number(process.env.PACK_CLASSIFICATION_TAG_MIN_SCORE))
-  ? Number(process.env.PACK_CLASSIFICATION_TAG_MIN_SCORE)
-  : 0.18;
+const CLIP_CLASSIFIER_CLASSIFICATION_VERSION = String(process.env.CLIP_CLASSIFIER_CLASSIFICATION_VERSION || process.env.CLIP_CLASSIFIER_MODEL_VERSION || 'v1').trim() || 'v1';
+const CLIP_CLASSIFIER_NSFW_THRESHOLD = Number.isFinite(Number(process.env.CLIP_CLASSIFIER_NSFW_THRESHOLD)) ? Number(process.env.CLIP_CLASSIFIER_NSFW_THRESHOLD) : null;
+const STICKER_TAG_MIN_SCORE = Number.isFinite(Number(process.env.STICKER_CLASSIFICATION_TAG_MIN_SCORE)) ? Number(process.env.STICKER_CLASSIFICATION_TAG_MIN_SCORE) : 0.2;
+const PACK_TAG_MIN_SCORE = Number.isFinite(Number(process.env.PACK_CLASSIFICATION_TAG_MIN_SCORE)) ? Number(process.env.PACK_CLASSIFICATION_TAG_MIN_SCORE) : 0.18;
 const MAX_TAGS_PER_ENTITY = Math.max(1, Math.min(10, Number(process.env.CLASSIFICATION_MAX_TAGS) || 6));
 
 const LABEL_TO_TAG = {
@@ -59,7 +43,9 @@ const normalizeTag = (value) => {
 };
 
 const mapLabelToTag = (label) => {
-  const key = String(label || '').trim().toLowerCase();
+  const key = String(label || '')
+    .trim()
+    .toLowerCase();
   return LABEL_TO_TAG[key] || normalizeTag(key);
 };
 
@@ -116,32 +102,18 @@ const normalizeClassificationResult = (payload) => {
   const topFromScores = scoreEntries[0] || null;
   const topFromLabels = topLabels[0] || null;
   const category = explicitCategory || topFromLabels?.label || topFromScores?.[0] || null;
-  const confidence = Number.isFinite(Number(payload?.confidence))
-    ? Number(Number(payload.confidence).toFixed(6))
-    : Number.isFinite(Number(topFromLabels?.score))
-      ? Number(Number(topFromLabels.score).toFixed(6))
-    : topFromScores
-      ? Number(Number(topFromScores[1]).toFixed(6))
-      : null;
+  const confidence = Number.isFinite(Number(payload?.confidence)) ? Number(Number(payload.confidence).toFixed(6)) : Number.isFinite(Number(topFromLabels?.score)) ? Number(Number(topFromLabels.score).toFixed(6)) : topFromScores ? Number(Number(topFromScores[1]).toFixed(6)) : null;
   const nsfwScore = Number.isFinite(Number(payload?.nsfw_score)) ? Number(Number(payload.nsfw_score).toFixed(6)) : null;
   const entropy = Number.isFinite(Number(payload?.entropy)) ? Number(Number(payload.entropy).toFixed(6)) : null;
-  const entropyNormalized = Number.isFinite(Number(payload?.entropy_normalized))
-    ? Number(Number(payload.entropy_normalized).toFixed(6))
-    : null;
-  const confidenceMargin = Number.isFinite(Number(payload?.confidence_margin))
-    ? Number(Number(payload.confidence_margin).toFixed(6))
-    : null;
-  const affinityWeight = Number.isFinite(Number(payload?.affinity_weight))
-    ? Number(Number(payload.affinity_weight).toFixed(6))
-    : null;
-  const affinityWeightRaw = Number.isFinite(Number(payload?.affinity_weight_raw))
-    ? Number(Number(payload.affinity_weight_raw).toFixed(6))
-    : null;
-  const imageHash = String(payload?.image_hash || '').trim().toLowerCase();
-
-  const llmExpansion = payload?.llm_expansion && typeof payload.llm_expansion === 'object'
-    ? payload.llm_expansion
-    : {};
+  const entropyNormalized = Number.isFinite(Number(payload?.entropy_normalized)) ? Number(Number(payload.entropy_normalized).toFixed(6)) : null;
+  const confidenceMargin = Number.isFinite(Number(payload?.confidence_margin)) ? Number(Number(payload.confidence_margin).toFixed(6)) : null;
+  const affinityWeight = Number.isFinite(Number(payload?.affinity_weight)) ? Number(Number(payload.affinity_weight).toFixed(6)) : null;
+  const affinityWeightRaw = Number.isFinite(Number(payload?.affinity_weight_raw)) ? Number(Number(payload.affinity_weight_raw).toFixed(6)) : null;
+  const imageHash = String(payload?.image_hash || '')
+    .trim()
+    .toLowerCase();
+
+  const llmExpansion = payload?.llm_expansion && typeof payload.llm_expansion === 'object' ? payload.llm_expansion : {};
   const llmSubtags = normalizeListOfStrings(llmExpansion?.subtags, 40);
   const llmStyleTraits = normalizeListOfStrings(llmExpansion?.style_traits, 20);
   const llmEmotions = normalizeListOfStrings(llmExpansion?.emotions, 20);
@@ -149,13 +121,15 @@ const normalizeClassificationResult = (payload) => {
 
   const similarImages = Array.isArray(payload?.similar_images)
     ? payload.similar_images
-      .map((entry) => ({
-        image_hash: String(entry?.image_hash || '').trim().toLowerCase(),
-        asset_id: entry?.asset_id ? String(entry.asset_id) : null,
-        similarity: Number.isFinite(Number(entry?.similarity)) ? Number(Number(entry.similarity).toFixed(6)) : null,
-      }))
-      .filter((entry) => entry.image_hash && Number.isFinite(Number(entry.similarity)))
-      .slice(0, 40)
+        .map((entry) => ({
+          image_hash: String(entry?.image_hash || '')
+            .trim()
+            .toLowerCase(),
+          asset_id: entry?.asset_id ? String(entry.asset_id) : null,
+          similarity: Number.isFinite(Number(entry?.similarity)) ? Number(Number(entry.similarity).toFixed(6)) : null,
+        }))
+        .filter((entry) => entry.image_hash && Number.isFinite(Number(entry.similarity)))
+        .slice(0, 40)
     : [];
 
   return {
@@ -188,18 +162,12 @@ const isClassifierNonRetryableError = (error) => {
   if (NON_RETRYABLE_CLASSIFIER_HTTP_STATUSES.has(status)) return true;
 
   const message = String(error?.message || '').toLowerCase();
-  return (
-    message.includes('could not create decoder object')
-    || message.includes('nao foi possivel decodificar a imagem')
-    || message.includes('não foi possível decodificar a imagem')
-  );
+  return message.includes('could not create decoder object') || message.includes('nao foi possivel decodificar a imagem') || message.includes('não foi possível decodificar a imagem');
 };
 
 const buildFallbackClassificationFromError = ({ asset, error }) => {
   const message = String(error?.message || '').toLowerCase();
-  const reasonTag = message.includes('decoder') || message.includes('decodificar')
-    ? 'decoder-error'
-    : 'non-retryable-error';
+  const reasonTag = message.includes('decoder') || message.includes('decodificar') ? 'decoder-error' : 'non-retryable-error';
 
   return {
     asset_id: asset.id,
@@ -210,12 +178,14 @@ const buildFallbackClassificationFromError = ({ asset, error }) => {
     confidence: 0,
     entropy: 0,
     confidence_margin: 0,
-    top_labels: [{
-      label: 'invalid image',
-      score: 1,
-      logit: null,
-      clip_score: null,
-    }],
+    top_labels: [
+      {
+        label: 'invalid image',
+        score: 1,
+        logit: null,
+        clip_score: null,
+      },
+    ],
     affinity_weight: 0,
     image_hash: asset?.sha256 || null,
     ambiguous: true,
@@ -541,15 +511,14 @@ export const classifierConfig = {
   classification_version: CLIP_CLASSIFIER_CLASSIFICATION_VERSION,
 };
 
-export const submitStickerClassificationFeedback = async ({
-  imageHash,
-  theme,
-  accepted,
-  assetId = null,
-}) => {
+export const submitStickerClassificationFeedback = async ({ imageHash, theme, accepted, assetId = null }) => {
   if (!CLIP_CLASSIFIER_ENABLED) return false;
-  const normalizedHash = String(imageHash || '').trim().toLowerCase();
-  const normalizedTheme = String(theme || '').trim().toLowerCase();
+  const normalizedHash = String(imageHash || '')
+    .trim()
+    .toLowerCase();
+  const normalizedTheme = String(theme || '')
+    .trim()
+    .toLowerCase();
   if (!normalizedHash || !normalizedTheme) return false;
   if (typeof globalThis.fetch !== 'function') return false;
 

package/app/modules/stickerPackModule/stickerDedicatedTaskWorkerRuntime.js

@@ -3,12 +3,7 @@ import { setQueueDepth } from '../../observability/metrics.js';
 import { isFeatureEnabled } from '../../services/featureFlagService.js';
 import { runStickerClassificationCycle } from './stickerClassificationBackgroundRuntime.js';
 import { runStickerAutoPackByTagsCycle } from './stickerAutoPackByTagsRuntime.js';
-import {
-  claimWorkerTask,
-  completeWorkerTask,
-  countWorkerTasksByStatus,
-  failWorkerTask,
-} from './stickerWorkerTaskQueueRepository.js';
+import { claimWorkerTask, completeWorkerTask, countWorkerTasksByStatus, failWorkerTask } from './stickerWorkerTaskQueueRepository.js';
 
 const parseEnvBool = (value, fallback) => {
   if (value === undefined || value === null || value === '') return fallback;
@@ -26,36 +21,17 @@ const clampInt = (value, fallback, min, max) => {
 
 const DEDICATED_WORKERS_ENABLED = parseEnvBool(process.env.STICKER_DEDICATED_WORKERS_ENABLED, true);
 const DEDICATED_WORKERS_FORCE_ENABLED = parseEnvBool(process.env.STICKER_DEDICATED_WORKERS_FORCE_ENABLED, false);
-const DEDICATED_WORKER_RETRY_DELAY_SECONDS = clampInt(
-  process.env.STICKER_DEDICATED_WORKER_RETRY_DELAY_SECONDS,
-  60,
-  5,
-  3600,
-);
-const DEDICATED_WORKER_POLL_INTERVAL_MS = clampInt(
-  process.env.STICKER_DEDICATED_WORKER_POLL_INTERVAL_MS,
-  2500,
-  250,
-  60_000,
-);
-const DEDICATED_WORKER_MAX_TASKS_PER_TICK = clampInt(
-  process.env.STICKER_DEDICATED_WORKER_MAX_TASKS_PER_TICK,
-  1,
-  1,
-  25,
-);
-const DEDICATED_WORKER_COHORT_KEY =
-  String(process.env.STICKER_DEDICATED_WORKER_COHORT_KEY || process.env.HOSTNAME || process.pid).trim()
-  || 'worker';
-
-const SUPPORTED_TASK_TYPES = new Set([
-  'classification_cycle',
-  'curation_cycle',
-  'rebuild_cycle',
-]);
+const DEDICATED_WORKER_RETRY_DELAY_SECONDS = clampInt(process.env.STICKER_DEDICATED_WORKER_RETRY_DELAY_SECONDS, 60, 5, 3600);
+const DEDICATED_WORKER_POLL_INTERVAL_MS = clampInt(process.env.STICKER_DEDICATED_WORKER_POLL_INTERVAL_MS, 2500, 250, 60_000);
+const DEDICATED_WORKER_MAX_TASKS_PER_TICK = clampInt(process.env.STICKER_DEDICATED_WORKER_MAX_TASKS_PER_TICK, 1, 1, 25);
+const DEDICATED_WORKER_COHORT_KEY = String(process.env.STICKER_DEDICATED_WORKER_COHORT_KEY || process.env.HOSTNAME || process.pid).trim() || 'worker';
+
+const SUPPORTED_TASK_TYPES = new Set(['classification_cycle', 'curation_cycle', 'rebuild_cycle']);
 
 const normalizeTaskType = (value) => {
-  const normalized = String(value || '').trim().toLowerCase();
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase();
   return SUPPORTED_TASK_TYPES.has(normalized) ? normalized : null;
 };
 
@@ -86,11 +62,7 @@ const runTaskHandler = async (taskType, payload = {}) => {
 };
 
 const refreshQueueDepthMetrics = async () => {
-  const [pending, processing, failed] = await Promise.all([
-    countWorkerTasksByStatus('pending'),
-    countWorkerTasksByStatus('processing'),
-    countWorkerTasksByStatus('failed'),
-  ]);
+  const [pending, processing, failed] = await Promise.all([countWorkerTasksByStatus('pending'), countWorkerTasksByStatus('processing'), countWorkerTasksByStatus('failed')]);
   setQueueDepth('sticker_worker_tasks_pending', pending);
   setQueueDepth('sticker_worker_tasks_processing', processing);
   setQueueDepth('sticker_worker_tasks_failed', failed);
@@ -107,13 +79,7 @@ const canRunDedicatedWorkers = async (taskType) => {
 
 export const isSupportedStickerWorkerTaskType = (taskType) => Boolean(normalizeTaskType(taskType));
 
-export const runDedicatedStickerWorkerTick = async (
-  {
-    taskType,
-    maxTasks = DEDICATED_WORKER_MAX_TASKS_PER_TICK,
-    retryDelaySeconds = DEDICATED_WORKER_RETRY_DELAY_SECONDS,
-  } = {},
-) => {
+export const runDedicatedStickerWorkerTick = async ({ taskType, maxTasks = DEDICATED_WORKER_MAX_TASKS_PER_TICK, retryDelaySeconds = DEDICATED_WORKER_RETRY_DELAY_SECONDS } = {}) => {
   const normalizedTaskType = normalizeTaskType(taskType);
   if (!normalizedTaskType) {
     return { executed: false, reason: 'invalid_task_type', task_type: taskType || null };
@@ -167,13 +133,7 @@ export const runDedicatedStickerWorkerTick = async (
   return stats;
 };
 
-export const startDedicatedStickerWorker = ({
-  taskType,
-  pollIntervalMs = DEDICATED_WORKER_POLL_INTERVAL_MS,
-  maxTasksPerTick = DEDICATED_WORKER_MAX_TASKS_PER_TICK,
-  retryDelaySeconds = DEDICATED_WORKER_RETRY_DELAY_SECONDS,
-  label = '',
-} = {}) => {
+export const startDedicatedStickerWorker = ({ taskType, pollIntervalMs = DEDICATED_WORKER_POLL_INTERVAL_MS, maxTasksPerTick = DEDICATED_WORKER_MAX_TASKS_PER_TICK, retryDelaySeconds = DEDICATED_WORKER_RETRY_DELAY_SECONDS, label = '' } = {}) => {
   const normalizedTaskType = normalizeTaskType(taskType);
   if (!normalizedTaskType) {
     throw new Error(`invalid_task_type:${taskType}`);

package/app/modules/stickerPackModule/stickerDomainEventBus.js

@@ -2,36 +2,30 @@ import logger from '../../utils/logger/loggerModule.js';
 import { isFeatureEnabled } from '../../services/featureFlagService.js';
 import { enqueueDomainEvent } from './domainEventOutboxRepository.js';
 
-const resolveDefaultIdempotencyKey = ({
-  eventType,
-  aggregateType,
-  aggregateId,
-  payload = null,
-}) => {
+const resolveDefaultIdempotencyKey = ({ eventType, aggregateType, aggregateId, payload = null }) => {
   const payloadKey = payload && typeof payload === 'object' ? JSON.stringify(payload).slice(0, 80) : '';
   return `${eventType}:${aggregateType}:${aggregateId}:${payloadKey}`.slice(0, 180);
 };
 
-export const publishStickerDomainEvent = async (
-  eventPayload,
-  { connection = null, force = false } = {},
-) => {
+export const publishStickerDomainEvent = async (eventPayload, { connection = null, force = false } = {}) => {
   const eventType = String(eventPayload?.eventType || '').trim();
   const aggregateType = String(eventPayload?.aggregateType || '').trim();
   const aggregateId = String(eventPayload?.aggregateId || '').trim();
 
   if (!eventType || !aggregateType || !aggregateId) return false;
 
-  const enabled = force ? true : await isFeatureEnabled('enable_domain_event_outbox', {
-    fallback: true,
-    subjectKey: `${aggregateType}:${aggregateId}`,
-  });
+  const enabled = force
+    ? true
+    : await isFeatureEnabled('enable_domain_event_outbox', {
+        fallback: true,
+        subjectKey: `${aggregateType}:${aggregateId}`,
+      });
   if (!enabled) return false;
 
   try {
     const idempotencyKey =
-      String(eventPayload?.idempotencyKey || '').trim()
-      || resolveDefaultIdempotencyKey({
+      String(eventPayload?.idempotencyKey || '').trim() ||
+      resolveDefaultIdempotencyKey({
         eventType,
         aggregateType,
         aggregateId,