@arcadialdev/arcality 3.0.3 → 3.0.4

package/tests/_helpers/agentic-runner.bundle.spec.js

@@ -27,6 +27,375 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// tests/_helpers/asset-resolver.ts
+var asset_resolver_exports = {};
+__export(asset_resolver_exports, {
+  createPlaceholderUpload: () => createPlaceholderUpload,
+  formatUploadAssetContext: () => formatUploadAssetContext,
+  listUploadAssets: () => listUploadAssets,
+  resolveUploadAsset: () => resolveUploadAsset,
+  syncAssetsFromBackend: () => syncAssetsFromBackend
+});
+function readJsonFile(filePath) {
+  const raw = fs2.readFileSync(filePath, "utf8").trim();
+  if (!raw)
+    return null;
+  return JSON.parse(raw);
+}
+function sanitizeIdPart(value) {
+  return String(value || "").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 80);
+}
+function normalizeMimeFromPath(filePath) {
+  const ext = path2.extname(filePath || "").toLowerCase();
+  if (ext === ".jpg" || ext === ".jpeg")
+    return "image/jpeg";
+  if (ext === ".webp")
+    return "image/webp";
+  if (ext === ".png")
+    return "image/png";
+  return "application/octet-stream";
+}
+function inferAssetType(...values) {
+  const text = values.join(" ").toLowerCase();
+  if (text.includes("banner") || text.includes("hero") || text.includes("cover"))
+    return "banner";
+  if (text.includes("logo"))
+    return "logo";
+  if (text.includes("avatar") || text.includes("profile") || text.includes("perfil"))
+    return "profile";
+  if (text.includes("product") || text.includes("producto"))
+    return "product";
+  return "image";
+}
+function normalizeAsset(raw, assetsDir = null) {
+  const assetId = String(raw.asset_id || raw.assetId || raw.id || "").trim();
+  const rawPath = String(raw.path || raw.file_path || raw.filePath || raw.storage_key || raw.storageKey || "").trim();
+  const filename = String(raw.filename || raw.fileName || (rawPath ? path2.basename(rawPath) : "") || "").trim();
+  const derivedId = filename ? `asset_${sanitizeIdPart(path2.basename(filename, path2.extname(filename)))}` : "";
+  const finalId = assetId || derivedId;
+  if (!finalId)
+    return null;
+  let filePath = rawPath || void 0;
+  if (filePath && !path2.isAbsolute(filePath)) {
+    const cwdCandidate = path2.resolve(process.cwd(), filePath);
+    const assetDirCandidate = assetsDir ? path2.resolve(assetsDir, filePath) : "";
+    filePath = fs2.existsSync(cwdCandidate) ? cwdCandidate : assetDirCandidate || cwdCandidate;
+  }
+  const label = String(raw.label || raw.user_label || raw.userLabel || filename || finalId).trim();
+  const type = String(raw.type || inferAssetType(label, filename)).trim().toLowerCase();
+  const mime = String(raw.mime || raw.mimeType || normalizeMimeFromPath(filePath || filename)).trim();
+  return {
+    assetId: finalId,
+    label,
+    type,
+    mime,
+    width: Number.isFinite(Number(raw.width)) ? Number(raw.width) : void 0,
+    height: Number.isFinite(Number(raw.height)) ? Number(raw.height) : void 0,
+    filePath,
+    filename,
+    isDefault: Boolean(raw.is_default || raw.isDefault)
+  };
+}
+function getDefaultAssetsDir() {
+  return process.env.ARCALITY_ASSETS_DIR || path2.join(process.cwd(), ".arcality", "assets");
+}
+function loadManifestAssets(assetsDir) {
+  const explicitFile = process.env.ARCALITY_ASSETS_FILE;
+  const manifestPath = explicitFile || path2.join(process.cwd(), ".arcality", "assets.json");
+  const inlineJson = process.env.ARCALITY_ASSETS_JSON;
+  try {
+    const parsed = inlineJson ? JSON.parse(inlineJson) : fs2.existsSync(manifestPath) ? readJsonFile(manifestPath) : null;
+    const list = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.assets) ? parsed.assets : [];
+    return list.map((entry) => normalizeAsset(entry, assetsDir)).filter(Boolean);
+  } catch (e) {
+    console.warn(`>>ARCALITY_STATUS>> Warning: no se pudo leer el inventario de assets (${e.message}).`);
+    return [];
+  }
+}
+function scanAssetsDir(assetsDir) {
+  try {
+    if (!fs2.existsSync(assetsDir))
+      return [];
+    return fs2.readdirSync(assetsDir, { withFileTypes: true }).filter((entry) => entry.isFile() && IMAGE_EXTENSIONS.has(path2.extname(entry.name).toLowerCase())).map((entry) => {
+      const filePath = path2.join(assetsDir, entry.name);
+      return normalizeAsset({
+        id: `asset_${sanitizeIdPart(path2.basename(entry.name, path2.extname(entry.name)))}`,
+        label: path2.basename(entry.name, path2.extname(entry.name)).replace(/[_-]+/g, " "),
+        path: filePath,
+        mime: normalizeMimeFromPath(filePath),
+        type: inferAssetType(entry.name)
+      }, assetsDir);
+    }).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function extractBackendAssets(payload) {
+  if (Array.isArray(payload))
+    return payload;
+  if (Array.isArray(payload?.assets))
+    return payload.assets;
+  if (Array.isArray(payload?.data?.assets))
+    return payload.data.assets;
+  if (Array.isArray(payload?.items))
+    return payload.items;
+  return [];
+}
+function listUploadAssets() {
+  const assetsDir = getDefaultAssetsDir();
+  const merged = [...loadManifestAssets(assetsDir), ...scanAssetsDir(assetsDir)];
+  const byId = /* @__PURE__ */ new Map();
+  for (const asset of merged) {
+    if (!byId.has(asset.assetId))
+      byId.set(asset.assetId, asset);
+  }
+  return Array.from(byId.values());
+}
+function formatUploadAssetContext() {
+  const assets = listUploadAssets();
+  const lines = assets.slice(0, 12).map((asset) => {
+    const size = asset.width && asset.height ? `${asset.width}x${asset.height}` : "unknown-size";
+    const defaultFlag = asset.isDefault ? " | default" : "";
+    return `- ${asset.label} | asset_id:${asset.assetId} | type:${asset.type} | mime:${asset.mime} | size:${size}${defaultFlag} | use:"arcasset://${asset.assetId}"`;
+  });
+  return `
+# AVAILABLE UPLOAD ASSETS
+${lines.length ? lines.join("\n") : "- No user assets registered for this project."}
+- Fallback allowed: use "placeholder:image/banner" for required image uploads when no suitable asset exists.
+`;
+}
+function findAsset(reference) {
+  const id = reference.replace(/^arcasset:\/\//i, "").trim();
+  const assets = listUploadAssets();
+  const lower = id.toLowerCase();
+  return assets.find(
+    (asset) => asset.assetId.toLowerCase() === lower || asset.label.toLowerCase() === lower || asset.filename?.toLowerCase() === lower
+  ) || null;
+}
+function inferPlaceholderSpec(label, reference = "") {
+  const text = `${label} ${reference}`.toLowerCase();
+  if (text.includes("logo") || text.includes("avatar") || text.includes("perfil")) {
+    return { width: 1024, height: 1024, name: "arcality-square-placeholder-1024x1024.png" };
+  }
+  if (text.includes("product") || text.includes("producto")) {
+    return { width: 1200, height: 1200, name: "arcality-product-placeholder-1200x1200.png" };
+  }
+  return { width: 1920, height: 1080, name: "arcality-banner-placeholder-1920x1080.png" };
+}
+function crc32(buffer) {
+  let crc = 4294967295;
+  for (let i = 0; i < buffer.length; i++) {
+    crc ^= buffer[i];
+    for (let j = 0; j < 8; j++) {
+      crc = crc >>> 1 ^ 3988292384 & -(crc & 1);
+    }
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function pngChunk(type, data) {
+  const typeBuffer = Buffer.from(type, "ascii");
+  const length = Buffer.alloc(4);
+  length.writeUInt32BE(data.length, 0);
+  const crc = Buffer.alloc(4);
+  crc.writeUInt32BE(crc32(Buffer.concat([typeBuffer, data])), 0);
+  return Buffer.concat([length, typeBuffer, data, crc]);
+}
+function createPngBuffer(width, height) {
+  const bytesPerPixel = 3;
+  const stride = width * bytesPerPixel + 1;
+  const raw = Buffer.alloc(stride * height);
+  for (let y = 0; y < height; y++) {
+    const rowStart = y * stride;
+    raw[rowStart] = 0;
+    for (let x = 0; x < width; x++) {
+      const offset = rowStart + 1 + x * bytesPerPixel;
+      const shade = (x + y) % 64;
+      raw[offset] = 30 + shade;
+      raw[offset + 1] = 108 + Math.floor(shade / 2);
+      raw[offset + 2] = 147;
+    }
+  }
+  const header = Buffer.alloc(13);
+  header.writeUInt32BE(width, 0);
+  header.writeUInt32BE(height, 4);
+  header[8] = 8;
+  header[9] = 2;
+  header[10] = 0;
+  header[11] = 0;
+  header[12] = 0;
+  return Buffer.concat([
+    Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]),
+    pngChunk("IHDR", header),
+    pngChunk("IDAT", zlib.deflateSync(raw)),
+    pngChunk("IEND", Buffer.alloc(0))
+  ]);
+}
+function createPlaceholderUpload(label = "file upload", reference = "") {
+  const spec = inferPlaceholderSpec(label, reference);
+  return {
+    name: spec.name,
+    mimeType: "image/png",
+    buffer: createPngBuffer(spec.width, spec.height)
+  };
+}
+function resolveUploadAsset(value, label = "file upload") {
+  const raw = String(value || "").replace(/^"|"$/g, "").trim();
+  if (!raw || /^placeholder:/i.test(raw) || /^dummy$/i.test(raw)) {
+    const assets = listUploadAssets();
+    const subtype = raw.startsWith("placeholder:image/") ? raw.substring("placeholder:image/".length).toLowerCase() : "";
+    const targetType = subtype || inferAssetType(label, raw);
+    const matchingAsset = assets.find((a) => a.type === targetType || a.label.toLowerCase().includes(targetType)) || assets.find((a) => !a.isDefault);
+    if (matchingAsset?.filePath && fs2.existsSync(matchingAsset.filePath)) {
+      console.log(`>>ARCALITY_STATUS>> Usando asset real configurado para el placeholder "${raw}": ${matchingAsset.filePath}`);
+      return matchingAsset.filePath;
+    }
+    return createPlaceholderUpload(label, raw);
+  }
+  if (/^arcasset:\/\//i.test(raw) || /^asset_[a-z0-9_-]+$/i.test(raw)) {
+    const asset = findAsset(raw);
+    if (asset?.filePath && fs2.existsSync(asset.filePath)) {
+      return asset.filePath;
+    }
+    console.warn(`>>ARCALITY_STATUS>> Asset "${raw}" no tiene archivo local disponible. Usando placeholder.`);
+    return createPlaceholderUpload(label, raw);
+  }
+  const filePath = path2.isAbsolute(raw) ? raw : path2.resolve(process.cwd(), raw);
+  if (fs2.existsSync(filePath)) {
+    return filePath;
+  }
+  console.warn(`>>ARCALITY_STATUS>> Archivo de upload no encontrado: "${raw}". Usando placeholder.`);
+  return createPlaceholderUpload(label, raw);
+}
+async function syncAssetsFromBackend() {
+  const apiUrl = process.env.ARCALITY_API_URL;
+  const apiKey = process.env.ARCALITY_API_KEY;
+  const projectId = process.env.ARCALITY_PROJECT_ID;
+  if (!apiUrl || !apiKey || !projectId) {
+    console.warn(`>>ARCALITY_STATUS>> \u26A0\uFE0F Asset sync omitido por configuraci\xF3n incompleta: API_URL=${apiUrl ? "OK" : "MISSING"}, API_KEY=${apiKey ? "OK" : "MISSING"}, PROJECT_ID=${projectId ? "OK" : "MISSING"}.`);
+    return;
+  }
+  try {
+    const assetsDir = getDefaultAssetsDir();
+    if (!fs2.existsSync(assetsDir)) {
+      fs2.mkdirSync(assetsDir, { recursive: true });
+    }
+    const url = `${apiUrl}/api/v1/projects/${projectId}/assets`;
+    console.log(`>>ARCALITY_STATUS>> \u{1F4E6} Consultando assets configurados del proyecto...`);
+    if (process.env.DEBUG) {
+      console.log(`[AssetSync] Fetching assets from: ${url}`);
+    }
+    const res = await globalThis.fetch(url, {
+      headers: {
+        "x-api-key": apiKey
+      }
+    });
+    if (!res.ok) {
+      console.warn(`>>ARCALITY_STATUS>> \u26A0\uFE0F Error al obtener assets del portal (${res.status}).`);
+      return;
+    }
+    const payload = await res.json();
+    const backendAssets = extractBackendAssets(payload);
+    if (!backendAssets.length) {
+      const payloadKeys = payload && typeof payload === "object" ? Object.keys(payload).slice(0, 8).join(", ") : typeof payload;
+      console.log(`>>ARCALITY_STATUS>> \u2139\uFE0F El proyecto no devolvi\xF3 assets utilizables. Se usar\xE1 placeholder cuando un upload lo requiera.`);
+      if (process.env.DEBUG) {
+        console.log(`[AssetSync] Payload shape without assets array: ${payloadKeys || "empty"}`);
+      }
+      return;
+    }
+    console.log(`>>ARCALITY_STATUS>> \u{1F4E6} Assets detectados en portal: ${backendAssets.length}`);
+    const localAssets = [];
+    for (const asset of backendAssets) {
+      const assetId = asset.asset_id || asset.assetId || asset.id;
+      if (!assetId) {
+        console.warn(`>>ARCALITY_STATUS>> \u26A0\uFE0F Asset ignorado porque no trae id utilizable: ${JSON.stringify(asset).slice(0, 200)}`);
+        continue;
+      }
+      const prefix = `${assetId}_`;
+      const files = fs2.existsSync(assetsDir) ? fs2.readdirSync(assetsDir) : [];
+      const existingFile = files.find((f) => f.startsWith(prefix));
+      let filename = asset.filename || asset.fileName;
+      let localFilePath = "";
+      let downloadNeeded = true;
+      if (existingFile) {
+        const candidatePath = path2.join(assetsDir, existingFile);
+        if (fs2.existsSync(candidatePath) && fs2.statSync(candidatePath).size > 0) {
+          filename = filename || existingFile.substring(prefix.length);
+          localFilePath = candidatePath;
+          downloadNeeded = false;
+        }
+      }
+      if (downloadNeeded) {
+        console.log(`>>ARCALITY_STATUS>> \u{1F4E5} Materializando asset del portal: "${asset.label}"...`);
+        const matRes = await globalThis.fetch(`${apiUrl}/api/v1/assets/${assetId}/materialize`, {
+          method: "POST",
+          headers: {
+            "x-api-key": apiKey,
+            "Content-Type": "application/json"
+          }
+        });
+        if (matRes.ok) {
+          const matData = await matRes.json();
+          const downloadUrl = matData.download_url || matData.downloadUrl;
+          const matFilename = matData.filename || matData.fileName || filename || `${assetId}.png`;
+          filename = matFilename;
+          const localFilename = `${assetId}_${matFilename}`;
+          localFilePath = path2.join(assetsDir, localFilename);
+          if (downloadUrl) {
+            console.log(`>>ARCALITY_STATUS>> \u{1F4E5} Descargando archivo de asset: "${asset.label}"...`);
+            const fileRes = await globalThis.fetch(downloadUrl);
+            if (fileRes.ok) {
+              const buffer = Buffer.from(await fileRes.arrayBuffer());
+              fs2.writeFileSync(localFilePath, buffer);
+              console.log(`>>ARCALITY_STATUS>> \u2705 Asset guardado localmente: ${localFilePath}`);
+            } else {
+              console.warn(`>>ARCALITY_STATUS>> \u26A0\uFE0F Error al descargar archivo de asset: ${fileRes.status}`);
+            }
+          }
+        } else {
+          console.warn(`>>ARCALITY_STATUS>> \u26A0\uFE0F Error al materializar asset: ${matRes.status}`);
+          filename = filename || `${assetId}.png`;
+          localFilePath = path2.join(assetsDir, `${assetId}_${filename}`);
+        }
+      }
+      localAssets.push({
+        asset_id: assetId,
+        label: asset.label || filename,
+        type: asset.type || "image",
+        mime: asset.mime || normalizeMimeFromPath(localFilePath || filename),
+        width: asset.width,
+        height: asset.height,
+        filePath: localFilePath,
+        path: localFilePath,
+        filename,
+        is_default: asset.is_default || asset.isDefault || false
+      });
+    }
+    const manifestPath = process.env.ARCALITY_ASSETS_FILE || path2.join(process.cwd(), ".arcality", "assets.json");
+    const manifestDir = path2.dirname(manifestPath);
+    if (!fs2.existsSync(manifestDir)) {
+      fs2.mkdirSync(manifestDir, { recursive: true });
+    }
+    fs2.writeFileSync(manifestPath, JSON.stringify(localAssets, null, 2), "utf8");
+    console.log(`>>ARCALITY_STATUS>> \u2705 Inventario local de assets actualizado (${localAssets.length}).`);
+    if (process.env.DEBUG) {
+      console.log(`[AssetSync] Local manifest updated at ${manifestPath}`);
+    }
+  } catch (e) {
+    console.warn(`>>ARCALITY_STATUS>> \u26A0\uFE0F Error durante la sincronizaci\xF3n de assets: ${e.message}`);
+  }
+}
+var fs2, path2, zlib, IMAGE_EXTENSIONS;
+var init_asset_resolver = __esm({
+  "tests/_helpers/asset-resolver.ts"() {
+    fs2 = __toESM(require("fs"));
+    path2 = __toESM(require("path"));
+    zlib = __toESM(require("zlib"));
+    IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp"]);
+  }
+});
 
 // src/configManager.mjs
 function isRealProjectId2(projectId) {
@@ -277,7 +646,12 @@ function simpleHash(str) {
   }
   return "ph_" + Math.abs(hash).toString(36);
 }
-async function createAdoTask(title, description) {
+function normalizeBugClassification(value) {
+  const text = String(value || "").trim();
+  const allowed = ["[Backend Bug]", "[Frontend Bug]", "[UI Regression]", "[Flaky/Stale Selector]"];
+  return allowed.find((category) => text.includes(category)) || "";
+}
+async function createAdoTask(title, description, metadata = {}) {
   const apiBase = getEffectiveApiBase();
   if (!apiBase) {
     if (process.env.DEBUG)
@@ -299,13 +673,18 @@ async function createAdoTask(title, description) {
   try {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), 15e3);
+    const bugClassification = normalizeBugClassification(metadata?.classification);
+    const taskTitle = bugClassification && !String(title).includes(bugClassification) ? `${bugClassification} ${title}` : title;
+    const taskDescription = bugClassification && !String(description).includes("Clasificacion") ? `**Clasificacion:** ${bugClassification}
+
+${description}` : description;
     const res = await fetch(`${apiBase}/api/v1/integrations/azuredevops/task`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         "x-api-key": key
       },
-      body: JSON.stringify({ project_id: projectId, title, description }),
+      body: JSON.stringify({ project_id: projectId, title: taskTitle, description: taskDescription }),
       signal: controller.signal
     });
     clearTimeout(timeout);
@@ -772,8 +1151,8 @@ async function scan_sensitive_data_exposure(page) {
 }
 
 // tests/_helpers/ai-agent-helper.ts
-var fs4 = __toESM(require("fs"));
-var path4 = __toESM(require("path"));
+var fs5 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
 
 // src/KnowledgeService.ts
 var crypto = __toESM(require("crypto"));
@@ -1443,25 +1822,29 @@ function formatQaContextSummary(analysis) {
 var qaSecurityTools = [
   {
     name: "test_xss_injection",
-    description: "Injects a standard XSS payload into an input field to test for reflected XSS vulnerabilities. Reports a vulnerability if an alert is triggered.",
+    description: "QA Security Skill: Inject a standard XSS payload into a visible input field identified by IDX. Use this to test reflected XSS on a component from CURRENT COMPONENTS.",
     parameters: {
       type: "object",
       properties: {
-        selector: { type: "string", description: "The CSS selector of the input field to test." }
+        idx: { type: "number", description: "The IDX of the input field from CURRENT COMPONENTS." },
+        payload_type: {
+          enum: ["script", "image", "svg"],
+          description: "Payload variant to inject. Defaults to script.",
+          default: "script"
+        }
       },
-      required: ["selector"]
+      required: ["idx"]
     }
   },
   {
     name: "test_auth_bypass",
-    description: "Attempts to directly navigate to a URL that should be protected to check for authentication bypass vulnerabilities.",
+    description: "QA Security Skill: Attempts to directly navigate to a protected route to check for authentication bypass vulnerabilities.",
     parameters: {
       type: "object",
       properties: {
-        url: { type: "string", description: "The protected URL to test." },
-        redirectUrl: { type: "string", description: "The expected URL to be redirected to if unauthorized (e.g., '/login')." }
+        target_url: { type: "string", description: "The protected URL or route to test. Relative paths are resolved against the current origin." }
       },
-      required: ["url", "redirectUrl"]
+      required: ["target_url"]
     }
   },
   {
@@ -1551,29 +1934,29 @@ var AIAgentHelper = class {
     try {
       let skillsContext = "";
       let loadedCount = 0;
-      const toolsRoot = process.env.ARCALITY_ROOT || path4.join(__dirname, "..", "..");
+      const toolsRoot = process.env.ARCALITY_ROOT || path5.join(__dirname, "..", "..");
       const possibleDirs = [
-        path4.join(toolsRoot, ".agent", "skills"),
-        path4.join(toolsRoot, ".agents", "skills")
+        path5.join(toolsRoot, ".agent", "skills"),
+        path5.join(toolsRoot, ".agents", "skills")
       ];
       for (const rootDir of possibleDirs) {
-        if (!fs4.existsSync(rootDir))
+        if (!fs5.existsSync(rootDir))
           continue;
         if (loadedCount === 0) {
           skillsContext += "\n\u{1F6E0}\uFE0F SKILLS INSTALADAS (Metodolog\xEDas activas):\n";
         }
-        const entries = fs4.readdirSync(rootDir, { withFileTypes: true });
+        const entries = fs5.readdirSync(rootDir, { withFileTypes: true });
         for (const entry of entries) {
           let content = "";
           let skillName = entry.name;
           if (entry.isDirectory()) {
-            const skillPath = path4.join(rootDir, entry.name, "SKILL.md");
-            if (fs4.existsSync(skillPath)) {
-              content = fs4.readFileSync(skillPath, "utf8");
+            const skillPath = path5.join(rootDir, entry.name, "SKILL.md");
+            if (fs5.existsSync(skillPath)) {
+              content = fs5.readFileSync(skillPath, "utf8");
             }
           } else if (entry.name.endsWith(".md")) {
-            const skillPath = path4.join(rootDir, entry.name);
-            content = fs4.readFileSync(skillPath, "utf8");
+            const skillPath = path5.join(rootDir, entry.name);
+            content = fs5.readFileSync(skillPath, "utf8");
           }
           if (content) {
             skillsContext += `
@@ -1596,9 +1979,9 @@ ${content}
   }
   loadMemory(prompt) {
     try {
-      const memoryFile = path4.join(this.contextDir, "memoria-agente.json");
-      if (fs4.existsSync(memoryFile)) {
-        const memories = JSON.parse(fs4.readFileSync(memoryFile, "utf8"));
+      const memoryFile = path5.join(this.contextDir, "memoria-agente.json");
+      if (fs5.existsSync(memoryFile)) {
+        const memories = JSON.parse(fs5.readFileSync(memoryFile, "utf8"));
         const keywords = prompt.toLowerCase().split(" ").filter((w) => w.length > 4);
         const relevantSuccess = memories.filter((m) => {
           if (!m.success)
@@ -1963,19 +2346,94 @@ ${relevantFailures.map((m) => `- ${m.prompt}`).join("\n")}
       components: sortedComponents
     };
   }
+  fallbackFailureClassification(failReason, failReasoning = "") {
+    const reason = `${failReason} ${failReasoning}`.toLowerCase();
+    if (reason.includes("network") || reason.includes("backend") || reason.includes("server") || reason.includes("internal_error") || reason.includes("500")) {
+      return "[Backend Bug]";
+    }
+    if (reason.includes("stale") || reason.includes("timeout") || reason.includes("selector") || reason.includes("idx")) {
+      return "[Flaky/Stale Selector]";
+    }
+    if (reason.includes("render") || reason.includes("blank") || reason.includes("ui_validation")) {
+      return "[UI Regression]";
+    }
+    return "[Frontend Bug]";
+  }
+  normalizeFailureClassification(raw) {
+    const text = (raw || "").trim();
+    const allowed = ["[Backend Bug]", "[Frontend Bug]", "[UI Regression]", "[Flaky/Stale Selector]"];
+    return allowed.find((category) => text.includes(category)) || null;
+  }
+  /**
+   * Classifies a terminal QA failure into a normalized bug bucket for reports and ADO.
+   */
+  async classifyFailure(prompt, failReason, failReasoning, history) {
+    const fallback = this.fallbackFailureClassification(failReason, failReasoning);
+    const isProxyMode = !!process.env.ARCALITY_API_URL;
+    if (!isProxyMode && !process.env.ANTHROPIC_API_KEY)
+      return fallback;
+    try {
+      const endpointUrl = isProxyMode ? `${process.env.ARCALITY_API_URL}/api/v1/ai/proxy` : "https://api.anthropic.com/v1/messages";
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (isProxyMode) {
+        headers["x-api-key"] = process.env.ARCALITY_API_KEY || "";
+        const missionId = process.env.ARCALITY_MISSION_ID || "";
+        if (missionId)
+          headers["x-mission-id"] = missionId;
+      } else {
+        headers["x-api-key"] = process.env.ANTHROPIC_API_KEY;
+        headers["anthropic-version"] = "2023-06-01";
+      }
+      const diagnosticPayload = {
+        mission: prompt,
+        fail_reason: failReason,
+        fail_reasoning: failReasoning || "None",
+        critical_network_error: this.criticalNetworkError || "None",
+        critical_js_error: this.criticalJsError || "None",
+        console_logs: this.logs.slice(-30),
+        recent_history: history.slice(-12)
+      };
+      const response = await fetch(endpointUrl, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          model: process.env.CLAUDE_MODEL || "claude-4-5-sonnet-latest",
+          max_tokens: 32,
+          system: "You classify terminal E2E QA failures. Reply with exactly one category string and no explanation: [Backend Bug], [Frontend Bug], [UI Regression], or [Flaky/Stale Selector].",
+          messages: [
+            {
+              role: "user",
+              content: `Classify this Arcality QA failure:
+${JSON.stringify(diagnosticPayload, null, 2)}`
+            }
+          ],
+          temperature: 0
+        })
+      });
+      if (!response.ok)
+        return fallback;
+      const data = await response.json();
+      const classification = this.normalizeFailureClassification(data.content?.[0]?.text);
+      return classification || fallback;
+    } catch {
+      return fallback;
+    }
+  }
   /**
    * Busca una acción sugerida en la memoria SIN usar tokens.
    * Compara URL, componentes visuales Y palabras clave del prompt.
    */
   async getActionFromGuia(prompt, historyLength) {
     try {
-      const fs6 = require("fs");
-      const path6 = require("path");
-      const memoryFile = path6.join(this.contextDir, "memoria-agente.json");
-      if (!fs6.existsSync(memoryFile)) {
+      const fs7 = require("fs");
+      const path7 = require("path");
+      const memoryFile = path7.join(this.contextDir, "memoria-agente.json");
+      if (!fs7.existsSync(memoryFile)) {
         return null;
       }
-      const memories = JSON.parse(fs6.readFileSync(memoryFile, "utf8"));
+      const memories = JSON.parse(fs7.readFileSync(memoryFile, "utf8"));
       const state = await this.getPageState();
       const currentUrl = this.page.url();
       const extractCriticalKeywords = (text) => {
@@ -2044,8 +2502,14 @@ ${relevantFailures.map((m) => `- ${m.prompt}`).join("\n")}
         let bestMatch = null;
         let bestMatchScore = -1;
         for (const c of state.components) {
-          const cleanMemName = (memStep.componentName || "").replace(/\[.*?\]/g, "").replace(/\(.*?\)/g, "").trim().toLowerCase();
-          const cleanCurrName = (c.name || "").replace(/\[.*?\]/g, "").replace(/\(.*?\)/g, "").trim().toLowerCase();
+          let cleanMemName = (memStep.componentName || "").replace(/\[.*?\]/g, "").replace(/\(.*?\)/g, "").trim().toLowerCase();
+          if (!cleanMemName) {
+            cleanMemName = (memStep.componentName || "").trim().toLowerCase();
+          }
+          let cleanCurrName = (c.name || "").replace(/\[.*?\]/g, "").replace(/\(.*?\)/g, "").trim().toLowerCase();
+          if (!cleanCurrName) {
+            cleanCurrName = (c.name || "").trim().toLowerCase();
+          }
           let score = -1;
           if (c.selector === memStep.action_data?.selector) {
             score = 100;
@@ -2215,6 +2679,18 @@ ${relevantFailures.map((m) => `- ${m.prompt}`).join("\n")}
         parameters: t.input_schema || t.parameters
       }))
     ];
+    const anthropicTools = rawTools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.parameters || t.input_schema
+    }));
+    if (anthropicTools.length > 0) {
+      const lastTool = anthropicTools[anthropicTools.length - 1];
+      anthropicTools[anthropicTools.length - 1] = {
+        ...lastTool,
+        cache_control: { type: "ephemeral" }
+      };
+    }
     const credentialsContext = process.env.LOGIN_USER && process.env.LOGIN_PASSWORD ? `
 \u{1F511} QA CREDENTIALS (Use if login is needed):
 - User: ${process.env.LOGIN_USER}
@@ -2222,6 +2698,12 @@ ${relevantFailures.map((m) => `- ${m.prompt}`).join("\n")}
 ` : "";
     const memoryContext = this.loadMemory(prompt);
     const skillsContext = this.loadSkills();
+    let assetContext = "";
+    try {
+      const { formatUploadAssetContext: formatUploadAssetContext2 } = (init_asset_resolver(), __toCommonJS(asset_resolver_exports));
+      assetContext = formatUploadAssetContext2();
+    } catch {
+    }
     let projectInfo = "";
     try {
       const { getProjectContext } = require("../src/projectInspector");
@@ -2263,11 +2745,11 @@ ${relevantFailures.map((m) => `- ${m.prompt}`).join("\n")}
     }
     let customUserContext = "";
     try {
-      const fs6 = require("fs");
-      const path6 = require("path");
-      const customContextPath = path6.join(process.cwd(), ".arcality", "qa-context.md");
+      const fs7 = require("fs");
+      const path7 = require("path");
+      const customContextPath = path7.join(process.cwd(), ".arcality", "qa-context.md");
       if (false) {
-        const content = fs6.readFileSync(customContextPath, "utf8");
+        const content = fs7.readFileSync(customContextPath, "utf8");
         customUserContext = `
 <CUSTOMER_BUSINESS_RULES>
 El Ing. de QA o Cliente final ha provisto las siguientes reglas estrictas para este negocio/dominio. DEBES priorizar esta informaci\xF3n sobre todas tus skills base:
@@ -2315,15 +2797,7 @@ ${this.qaContextPromptCache}
         text: `# IDENTITY
 You are **Arcality**, an elite Senior QA Web Testing Agent. You have 10+ years of experience in manual and automated testing. You are meticulous, thorough, and NEVER take shortcuts. You treat every mission as a real client engagement where your professional reputation is on the line. You MUST use your full arsenal of QA tools \u2014 guessing and blind retries are UNACCEPTABLE.
 
-# MISSION
-${prompt}
-
-${projectInfo}
-${skillsContext}
-${customUserContext}
-${memoryContext}
-${credentialsContext}
-${memoryBackendContext}`
+`
       },
       {
         type: "text",
@@ -2421,6 +2895,13 @@ These are NOT optional. You MUST use these tools in these situations:
 13. **NATIVE CONTROLS**: For \`<input type="time">\`, \`<input type="date">\`, or similar native pickers, NEVER use \`fill\` repeatedly. Use \`interact_native_control\` or \`send_keyboard_event\` instead. If \`fill\` fails once, switch strategy immediately.
 14. **USER-DEFINED BUGS (MANDATORY & IMMEDIATE)**: If the prompt explicitly defines a condition as a bug (e.g., "Si no te deja eliminarla, es un bug de la aplicaci\xF3n", or "If X fails it's a bug"), and you encounter that condition, you MUST call \`report_application_bug\` IMMEDIATELY in that exact same turn. DO NOT perform any intermediate UI actions (such as clicking "Cancelar", closing modals, or navigating away) before calling the tool. Any intermediate UI action will cause you to lose your reasoning context in the next turn and enter an infinite loop. The call to \`report_application_bug\` must take absolute priority over any UI cleanup or close actions. DO NOT dismiss it as "expected business logic" or "referential integrity". The user's definition of a bug OVERRIDES all general reasoning.
 
+15. **FILE UPLOAD FIELDS (MANDATORY PROTOCOL)**: When the current step requires uploading an image or file (a dropzone component with text like "arrastra", "explora", "formatos", "JPEG", "PNG", or an input with aria-label containing "imagen" or "file"):
+   - You MUST use the \`fill\` action on the file input with one of the values from the \`# AVAILABLE UPLOAD ASSETS\` section below (format: \`arcasset://<asset_id>\`).
+   - If no asset matches the required type, use the value \`"placeholder:image/banner"\` \u2014 the runner will automatically generate a valid placeholder PNG image.
+   - **NEVER** report a bug or inability to proceed just because you see a file upload field. You ALWAYS have a fallback.
+   - **NEVER** skip the image step. If clicking "Siguiente" is blocked by a required image field, locate the file input and use \`fill\` with \`arcasset://\` or \`placeholder:image/banner\`.
+   - To locate the file input: look for a component with type \`[input]\` adjacent to dropzone text, OR use \`inspect_element_details\` on the dropzone container to find its nested \`input[type=file]\`.
+
 # WIZARD & MULTI-STEP FORMS (CRITICAL)
 When a form is divided into numbered steps (e.g., Step 1 \u2192 Step 2 \u2192 Step 3):
 
@@ -2460,7 +2941,22 @@ When a form is divided into numbered steps (e.g., Step 1 \u2192 Step 2 \u2192 St
 
 11. **COMBOBOX KEYBOARD FALLBACK**: If you click a combobox/select field and the dropdown options (\`[li]\`, \`[OPTION]\`) are NOT visible after 1 turn, use this keyboard sequence: a) Click the combobox field ONCE. b) Use \`send_keyboard_event\` with key "ArrowDown" to open the options and highlight the first one. c) Use \`send_keyboard_event\` with key "Enter" to select it. This avoids the toggle problem and works with all dropdown implementations.
 
-12. **ERROR STOP PROTOCOL (CRITICAL)**: If you see a message starting with \`\u{1F6D1} [ERROR_CR\xCDTICO]\` or \`\u{1F6D1} ERROR POST-GUARDADO\`, do NOT assume it is a transient error. You MUST analyze the text. If it says "ya existe" or "duplicado", you MUST change the offending field value (e.g., add a random number) AND click the save button in the SAME turn. Do NOT waste a turn closing the error toast. If you retry without changing any data and the error persists, you MUST use \`report_inability_to_proceed\` immediately. Looping on the same error toast is FORBIDDEN.`
+12. **ERROR STOP PROTOCOL (CRITICAL)**: If you see a message starting with \`\u{1F6D1} [ERROR_CR\xCDTICO]\` or \`\u{1F6D1} ERROR POST-GUARDADO\`, do NOT assume it is a transient error. You MUST analyze the text. If it says "ya existe" or "duplicado", you MUST change the offending field value (e.g., add a random number) AND click the save button in the SAME turn. Do NOT waste a turn closing the error toast. If you retry without changing any data and the error persists, you MUST use \`report_inability_to_proceed\` immediately. Looping on the same error toast is FORBIDDEN.`,
+        cache_control: { type: "ephemeral" }
+      },
+      {
+        type: "text",
+        text: `
+# MISSION
+${prompt}
+
+${projectInfo}
+${skillsContext}
+${customUserContext}
+${memoryContext}
+${credentialsContext}
+${memoryBackendContext}
+${assetContext}`
       }
     ];
     if (this.testInfo) {
@@ -2544,11 +3040,7 @@ ${history.slice(-25).join("\n") || "None"}`
               model: process.env.CLAUDE_MODEL || "claude-4-5-sonnet-latest",
               max_tokens: 4096,
               system: systemPromptBlocks,
-              tools: rawTools.map((t) => ({
-                name: t.name,
-                description: t.description,
-                input_schema: t.parameters || t.input_schema
-              })),
+              tools: anthropicTools,
               messages: anthropicMessages,
               temperature: 0.2
             })
@@ -2571,7 +3063,7 @@ ${history.slice(-25).join("\n") || "None"}`
           const delay = Math.pow(2, retryCount) * 1e3;
           console.log(`
 >>ARCALITY_STATUS>> \u26A0\uFE0F Arcality est\xE1 saturado (${response.status}). Reintentando...`);
-          await new Promise((resolve) => setTimeout(resolve, delay));
+          await new Promise((resolve2) => setTimeout(resolve2, delay));
           continue;
         }
         throw new Error(`Arcality Brain Error ${response.status}: ${errorText}`);
@@ -2886,7 +3378,7 @@ ${history.slice(-25).join("\n") || "None"}`
             }
           }
         } else if (toolName === "test_xss_injection") {
-          const { idx, payload_type } = toolInput;
+          const { idx, payload_type = "script" } = toolInput;
           const el = state.components.find((c) => c.idx === idx);
           if (!el) {
             toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Element idx ${idx} not found.` });
@@ -2898,7 +3390,8 @@ ${history.slice(-25).join("\n") || "None"}`
             if (payload_type === "svg")
               payload = "<svg onload=alert(1)>";
             try {
-              const locator = this.page.locator(`xpath=${el.selector}`).first();
+              const frame = this.page.frames()[el.frameIdx] || this.page.mainFrame();
+              const locator = frame.locator(el.selector).first();
               await locator.fill(payload);
               toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Payload inyectado. Aseg\xFArate de probar si el payload fue ejecutado revisando el DOM, o realiza el sumbit y observa si el input regres\xF3 renderizado tal cual o sanitizado.` });
               if (this.testInfo)
@@ -3423,9 +3916,10 @@ var SecurityScanner = class {
 
 // tests/_helpers/agentic-runner.spec.ts
 var import_config = require("dotenv/config");
-var fs5 = __toESM(require("fs"));
-var path5 = __toESM(require("path"));
+var fs6 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
 var crypto2 = __toESM(require("crypto"));
+init_asset_resolver();
 var _sessionRuleCache = /* @__PURE__ */ new Set();
 function captureValidationRule(errorMessage, context) {
   const key = errorMessage.substring(0, 80).toLowerCase().trim();
@@ -3455,11 +3949,11 @@ function writeBatchMissionResult(payload) {
   if (!runDomainDir)
     return;
   try {
-    if (!fs5.existsSync(runDomainDir)) {
-      fs5.mkdirSync(runDomainDir, { recursive: true });
+    if (!fs6.existsSync(runDomainDir)) {
+      fs6.mkdirSync(runDomainDir, { recursive: true });
     }
-    fs5.writeFileSync(
-      path5.join(runDomainDir, "mission-result.json"),
+    fs6.writeFileSync(
+      path6.join(runDomainDir, "mission-result.json"),
       JSON.stringify(payload, null, 2)
     );
   } catch {
@@ -3480,10 +3974,15 @@ function writeBatchMissionResult(payload) {
   const history = [];
   const urlHistory = [];
   const stepsData = [];
-  const memoryFile = path5.join(contextDir, "memoria-arcality.json");
-  if (fs5.existsSync(memoryFile)) {
+  try {
+    await syncAssetsFromBackend();
+  } catch (e) {
+    console.warn(`>>ARCALITY_STATUS>> \u26A0\uFE0F Error al sincronizar assets: ${e.message}`);
+  }
+  const memoryFile = path6.join(contextDir, "memoria-arcality.json");
+  if (fs6.existsSync(memoryFile)) {
     try {
-      fs5.unlinkSync(memoryFile);
+      fs6.unlinkSync(memoryFile);
     } catch {
     }
   }
@@ -3522,18 +4021,34 @@ function writeBatchMissionResult(payload) {
   let lastSeenErrorToast = "";
   let accumulatedCost = 0;
   let totalMissionUsage = { input_tokens: 0, output_tokens: 0, cache_creation_input_tokens: 0, cache_read_input_tokens: 0 };
+  let bugClassification = "";
+  const missionSummaryPaths = /* @__PURE__ */ new Set();
+  const updateSavedMissionClassification = () => {
+    if (!bugClassification)
+      return;
+    for (const summaryPath of missionSummaryPaths) {
+      try {
+        if (!fs6.existsSync(summaryPath))
+          continue;
+        const data = JSON.parse(fs6.readFileSync(summaryPath, "utf8"));
+        data.bug_classification = bugClassification;
+        fs6.writeFileSync(summaryPath, JSON.stringify(data, null, 2));
+      } catch {
+      }
+    }
+  };
   const saveMissionResults = () => {
     if (resultsSaved)
       return;
     resultsSaved = true;
-    if (!fs5.existsSync(contextDir))
-      fs5.mkdirSync(contextDir, { recursive: true });
+    if (!fs6.existsSync(contextDir))
+      fs6.mkdirSync(contextDir, { recursive: true });
     const finalSuccess = aiMarkedSuccess && !hasCriticalError;
     try {
-      const memoryFile2 = path5.join(contextDir, "memoria-arcality.json");
+      const memoryFile2 = path6.join(contextDir, "memoria-arcality.json");
       let memories = [];
-      if (fs5.existsSync(memoryFile2)) {
-        const content = fs5.readFileSync(memoryFile2, "utf8").trim();
+      if (fs6.existsSync(memoryFile2)) {
+        const content = fs6.readFileSync(memoryFile2, "utf8").trim();
         if (content) {
           try {
             memories = JSON.parse(content);
@@ -3604,10 +4119,11 @@ function writeBatchMissionResult(payload) {
         error: hasCriticalError,
         fail_reason: failReason,
         fail_reasoning: failReasoning,
+        bug_classification: bugClassification || null,
         timestamp: Date.now()
       };
       memories.push(missionData);
-      fs5.writeFileSync(memoryFile2, JSON.stringify(memories, null, 2));
+      fs6.writeFileSync(memoryFile2, JSON.stringify(memories, null, 2));
       if (process.env.DEBUG)
         console.log(`>>ARCALITY_STATUS>> \u{1F9E0} Memoria guardada: ${cleanSteps.length} pasos limpios (${rawSteps.length - cleanSteps.length} corruptos filtrados)`);
     } catch (err) {
@@ -3624,22 +4140,26 @@ function writeBatchMissionResult(payload) {
         error: hasCriticalError,
         fail_reason: failReason,
         fail_reasoning: failReasoning,
+        bug_classification: bugClassification || null,
         usage: totalMissionUsage,
         target: process.env.BASE_URL || "",
         target_path: process.env.TARGET_PATH || "",
         report_dir: process.env.REPORTS_DIR || "",
         timestamp: timestampIso
       };
-      const logPath = path5.join(contextDir, `agent-log-${timestampMs}.json`);
-      fs5.writeFileSync(logPath, JSON.stringify(summaryPayload, null, 2));
-      const runDomainDir = process.env.ARCALITY_RUN_DOMAIN_DIR || path5.dirname(contextDir);
-      const durableLogsDir = path5.join(runDomainDir, "logs");
-      fs5.mkdirSync(durableLogsDir, { recursive: true });
-      fs5.writeFileSync(
-        path5.join(durableLogsDir, `mission-log-${timestampMs}.json`),
-        JSON.stringify(summaryPayload, null, 2)
-      );
+      const logPath = path6.join(contextDir, `agent-log-${timestampMs}.json`);
+      fs6.writeFileSync(logPath, JSON.stringify(summaryPayload, null, 2));
+      missionSummaryPaths.add(logPath);
+      const runDomainDir = process.env.ARCALITY_RUN_DOMAIN_DIR || path6.dirname(contextDir);
+      const durableLogsDir = path6.join(runDomainDir, "logs");
+      fs6.mkdirSync(durableLogsDir, { recursive: true });
+      const durableLogPath = path6.join(durableLogsDir, `mission-log-${timestampMs}.json`);
+      fs6.writeFileSync(durableLogPath, JSON.stringify(summaryPayload, null, 2));
+      missionSummaryPaths.add(durableLogPath);
       writeBatchMissionResult(summaryPayload);
+      if (runDomainDir) {
+        missionSummaryPaths.add(path6.join(runDomainDir, "mission-result.json"));
+      }
       try {
         const historyLine = JSON.stringify({
           ts: timestampIso,
@@ -3649,12 +4169,12 @@ function writeBatchMissionResult(payload) {
           fail_reason: failReason,
           report_dir: process.env.REPORTS_DIR || ""
         }) + "\n";
-        fs5.appendFileSync(
-          path5.join(contextDir, "arcality-history.log"),
+        fs6.appendFileSync(
+          path6.join(contextDir, "arcality-history.log"),
           historyLine
         );
-        fs5.appendFileSync(
-          path5.join(durableLogsDir, "arcality-history.log"),
+        fs6.appendFileSync(
+          path6.join(durableLogsDir, "arcality-history.log"),
           historyLine
         );
       } catch (e) {
@@ -3849,11 +4369,11 @@ function writeBatchMissionResult(payload) {
           timestamp: Date.now()
         };
         try {
-          const memoryFile2 = path5.join(contextDir, "memoria-agente.json");
+          const memoryFile2 = path6.join(contextDir, "memoria-agente.json");
           let memories = [];
-          if (fs5.existsSync(memoryFile2)) {
+          if (fs6.existsSync(memoryFile2)) {
             try {
-              memories = JSON.parse(fs5.readFileSync(memoryFile2, "utf8"));
+              memories = JSON.parse(fs6.readFileSync(memoryFile2, "utf8"));
             } catch {
               memories = [];
             }
@@ -3865,14 +4385,14 @@ function writeBatchMissionResult(payload) {
           if (existingIdx < 0) {
             if (resolvedStepsData.length > 0) {
               memories.push(localMemoryData);
-              fs5.writeFileSync(memoryFile2, JSON.stringify(memories, null, 2));
+              fs6.writeFileSync(memoryFile2, JSON.stringify(memories, null, 2));
               console.log(`>>ARCALITY_STATUS>> \u2728 Memoria sincronizada en memoria-agente.json (${resolvedStepsData.length} pasos). Arcality entrar\xE1 en MODO GU\xCDA.`);
             } else {
               console.warn(`>>ARCALITY_STATUS>> \u26A0\uFE0F Memoria NO sincronizada: el patr\xF3n del backend tiene 0 pasos t\xE9cnicos v\xE1lidos (steps_technical vac\xEDo).`);
             }
           } else if (!existingHasSteps && resolvedStepsData.length > 0) {
             memories[existingIdx] = localMemoryData;
-            fs5.writeFileSync(memoryFile2, JSON.stringify(memories, null, 2));
+            fs6.writeFileSync(memoryFile2, JSON.stringify(memories, null, 2));
             console.log(`>>ARCALITY_STATUS>> \u{1F504} Patr\xF3n corrupto (0 pasos) sobreescrito en memoria-agente.json (${resolvedStepsData.length} pasos nuevos). MODO GU\xCDA activado.`);
           } else {
             console.log(`>>ARCALITY_STATUS>> \u2139\uFE0F Patr\xF3n ya existe en memoria-agente.json con ${(memories[existingIdx]?.steps_data || []).length} pasos. MODO GU\xCDA activado sin re-escritura.`);
@@ -4142,7 +4662,16 @@ ${patternContext}` : prompt;
           saveMissionResults();
           break;
         } else {
-          throw err;
+          const errMsg = err?.message || String(err);
+          console.error(`>>ARCALITY_STATUS>> \u{1F6D1} Error terminal del motor IA: ${errMsg}`);
+          aiMarkedSuccess = false;
+          hasCriticalError = true;
+          failReason = "agent_runtime_error";
+          failReasoning = errMsg;
+          isFinished = true;
+          history.push(`Turno ${stepCount}: \u{1F6D1} [AGENT RUNTIME ERROR] ${errMsg}`);
+          saveMissionResults();
+          break;
         }
       }
       if (response.usage) {
@@ -4216,7 +4745,7 @@ Acci\xF3n bloqueada: Bucle de tipo ${loopType} sobre los elementos ${Array.from(
       const lastSixHistory = history.slice(-6);
       const consecutiveWaits = lastSixHistory.filter((h) => h.includes('wait en "')).length;
       if (consecutiveWaits >= 3) {
-        const blankEvidencePath = path5.join(contextDir, `portal-blank-state-${Date.now()}.png`);
+        const blankEvidencePath = path6.join(contextDir, `portal-blank-state-${Date.now()}.png`);
         await page.screenshot({ path: blankEvidencePath, fullPage: true }).catch(() => {
         });
         const blankUrl = page.url();
@@ -4431,12 +4960,17 @@ Acci\xF3n bloqueada: Bucle de tipo ${loopType} sobre los elementos ${Array.from(
             } else {
               await page.waitForTimeout(500);
             }
-          } else if (step.action === "fill" && loc && step.value) {
+          } else if (step.action === "fill" && loc) {
             const inputType = await loc.evaluate((el) => el.tagName === "INPUT" ? (el.type || "").toLowerCase() : null).catch(() => null);
             if (inputType === "file") {
-              console.log(`    \u{1F4C2} Detectado input de archivo. Subiendo: "${step.value}"`);
-              const filePath = step.value.replace(/^"|"$/g, "").trim();
-              await loc.setInputFiles(filePath);
+              const rawUploadValue = String(step.value || "placeholder:image/banner");
+              console.log(`    \u{1F4C2} Detectado input de archivo. Subiendo: "${rawUploadValue}"`);
+              const fileVal = rawUploadValue.replace(/^"|"$/g, "").trim();
+              const desc = step.description || "file upload";
+              const resolvedAsset = resolveUploadAsset(fileVal, desc);
+              await loc.setInputFiles(resolvedAsset);
+            } else if (!step.value) {
+              console.log(`    \u26A0\uFE0F Acci\xF3n fill sin valor para un campo no-file. Se omite para evitar corrupci\xF3n de estado.`);
             } else if (inputType === "date" || inputType === "time" || inputType === "datetime-local") {
               console.log(`    \u{1F39B}\uFE0F Detectado input nativo (${inputType}). Usando estrategia segura para: "${step.value}"`);
               try {
@@ -4488,7 +5022,7 @@ Acci\xF3n bloqueada: Bucle de tipo ${loopType} sobre los elementos ${Array.from(
                   const panelCount = Math.min(panels.length, 6);
                   if (panelCount >= 2 && emptyPanelCount >= panelCount * 0.6) {
                     const blankUrl = page.url();
-                    const blankEvidencePath = path5.join(contextDir, `portal-blank-dashboard-${Date.now()}.png`);
+                    const blankEvidencePath = path6.join(contextDir, `portal-blank-dashboard-${Date.now()}.png`);
                     await page.screenshot({ path: blankEvidencePath, fullPage: true }).catch(() => {
                     });
                     console.error(`
@@ -4772,8 +5306,8 @@ Acci\xF3n bloqueada: Bucle de tipo ${loopType} sobre los elementos ${Array.from(
       console.log("\u{1F916} [SMART-YAML] Generating mission card...");
     const smartYaml = await agent.summarizeMissionToYaml(prompt, history, target);
     if (smartYaml) {
-      const yamlPath = path5.join(contextDir, "last-mission-smart.yaml");
-      fs5.writeFileSync(yamlPath, smartYaml);
+      const yamlPath = path6.join(contextDir, "last-mission-smart.yaml");
+      fs6.writeFileSync(yamlPath, smartYaml);
       console.log(`>>ARCALITY_STATUS>> \u{1F4DD} Smart Mission Card generated.`);
       await testInfo.attach("smart_mission_card", {
         body: Buffer.from(smartYaml, "utf-8"),
@@ -4827,12 +5361,39 @@ Evidence: ${JSON.stringify(v.evidence).substring(0, 400)}`,
   if (!aiMarkedSuccess) {
     if (process.env.DEBUG)
       console.log(`>>ARCALITY_STATUS>> \u{1F4CA} Uso total de tokens esta misi\xF3n: IN=${totalMissionUsage.input_tokens} | OUT=${totalMissionUsage.output_tokens} | Cache writes=${totalMissionUsage.cache_creation_input_tokens} | Cache reads=${totalMissionUsage.cache_read_input_tokens}`);
+    bugClassification = await agent.classifyFailure(prompt, failReason || "unknown_failure", failReasoning, history);
+    console.log(`>>ARCALITY_STATUS>> Bug classification: ${bugClassification}`);
+    updateSavedMissionClassification();
+    await testInfo.attach("bug_classification", {
+      body: Buffer.from(bugClassification, "utf-8"),
+      contentType: "text/plain"
+    });
+    try {
+      const { createAdoTask: createAdoTask2 } = await Promise.resolve().then(() => (init_arcalityClient(), arcalityClient_exports));
+      const shortPrompt = prompt.length > 90 ? prompt.substring(0, 87).trimEnd() + "..." : prompt;
+      const adoTitle = `[Arcality QA] ${shortPrompt}`;
+      const adoDescription = [
+        `**Bug detectado automaticamente por Arcality QA**`,
+        ``,
+        `**Clasificacion:** ${bugClassification}`,
+        `**Fail reason:** ${failReason || "unknown_failure"}`,
+        failReasoning ? `**Analisis:** ${failReasoning}` : `**Analisis:** No disponible.`,
+        `**Mision:** ${prompt}`,
+        `**Historial reciente:**`,
+        history.slice(-8).map((h) => `- ${h}`).join("\n"),
+        `**Fecha:** ${(/* @__PURE__ */ new Date()).toISOString()}`
+      ].join("\n");
+      await createAdoTask2(adoTitle, adoDescription, { classification: bugClassification }).catch(() => null);
+    } catch {
+    }
     await persistCollectiveMemory(true).catch(() => {
     });
     let finalErrorMsg = `Misi\xF3n no completada o finalizada con errores.
 
 `;
     finalErrorMsg += `======================================================
+`;
+    finalErrorMsg += `Bug classification: ${bugClassification}
 `;
     finalErrorMsg += `\u{1F3AF} TIPO DE FALLO: ${failReason}
 `;
@@ -4848,15 +5409,15 @@ ${failReasoning}
     if (process.env.DEBUG)
       console.log(`>>ARCALITY_STATUS>> \u{1F4CA} Uso total de tokens esta misi\xF3n: IN=${totalMissionUsage.input_tokens} | OUT=${totalMissionUsage.output_tokens} | Cache writes=${totalMissionUsage.cache_creation_input_tokens} | Cache reads=${totalMissionUsage.cache_read_input_tokens}`);
   }
-  if (fs5.existsSync(contextDir)) {
+  if (fs6.existsSync(contextDir)) {
     try {
-      const files = fs5.readdirSync(contextDir);
+      const files = fs6.readdirSync(contextDir);
       for (const file of files) {
         if (file.endsWith(".json") || file.endsWith(".png")) {
-          fs5.unlinkSync(path5.join(contextDir, file));
+          fs6.unlinkSync(path6.join(contextDir, file));
         }
       }
-      fs5.rmSync(contextDir, { recursive: true, force: true });
+      fs6.rmSync(contextDir, { recursive: true, force: true });
       console.log(`>>ARCALITY_STATUS>> \u{1F9F9} Carpeta context eliminada (Memoria ef\xEDmera completada).`);
     } catch (err) {
       console.warn(`No se pudo limpiar la carpeta context: ${err}`);