@arcadialdev/arcality 3.0.3 → 4.0.0

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);
@@ -601,6 +980,34 @@ var sendKeyboardEventTool = {
     required: ["key"]
   }
 };
+var typeSequentiallyTool = {
+  name: "type_sequentially",
+  description: "QA Skill: Type a full text string character by character into a specific field. Use this for masked numeric inputs, OTP/PIN/CLABE/identification codes, virtual-keyboard flows, or whenever the mission explicitly says to type manually, digit by digit, or character by character. Prefer this over repeated clicks when the field is already visible but normal fill may not reflect the mask correctly.",
+  input_schema: {
+    type: "object",
+    properties: {
+      idx: {
+        type: "number",
+        description: "The IDX of the input-like element to focus before typing"
+      },
+      text: {
+        type: "string",
+        description: "The exact text to type sequentially"
+      },
+      delay_ms: {
+        type: "number",
+        description: "Delay between keystrokes in milliseconds (default: 80)",
+        default: 80
+      },
+      clear_first: {
+        type: "boolean",
+        description: "Whether to clear any existing value before typing (default: true)",
+        default: true
+      }
+    },
+    required: ["idx", "text"]
+  }
+};
 var interactNativeControlTool = {
   name: "interact_native_control",
   description: "QA Skill: Interact with native HTML controls that standard click/fill may not handle correctly. This includes: <input type='time'>, <input type='date'>, <input type='datetime-local'>, <input type='color'>, <input type='range'>, <select> with optgroup, and contenteditable elements. This tool uses Playwright's specialized methods (selectOption, fill with format coercion, press sequences) to reliably set values. ALWAYS prefer this tool over manual fill for time/date inputs.",
@@ -656,6 +1063,7 @@ var qaAdvancedTools = [
   restoreNavigationCheckpointTool,
   createTestEvidenceTool,
   sendKeyboardEventTool,
+  typeSequentiallyTool,
   interactNativeControlTool,
   scrollPageTool
 ];
@@ -772,8 +1180,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"));
@@ -1300,6 +1708,112 @@ function isPlaceholderRule(rule) {
 function isRecognizedSection(title) {
   return RECOGNIZED_SECTION_PATTERNS.some((pattern) => pattern.test(title));
 }
+function asTrimmedString(value) {
+  if (typeof value !== "string")
+    return null;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : null;
+}
+function asStringList(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.map((item) => asTrimmedString(item)).filter((item) => Boolean(item));
+}
+function loadQaContextGovernance(projectRoot, contextExists) {
+  const metadataPath = path.join(projectRoot, ".arcality", "qa-context.meta.json");
+  const warnings = [];
+  const emptyResult = {
+    path: metadataPath,
+    exists: false,
+    isValid: false,
+    enforcementMode: getQaContextGovernanceMode(),
+    version: null,
+    updatedBy: null,
+    approvedBy: null,
+    ownerTeam: null,
+    changeSummary: null,
+    effectiveFrom: null,
+    tags: [],
+    warnings
+  };
+  if (!fs.existsSync(metadataPath)) {
+    if (contextExists) {
+      warnings.push("No se encontro qa-context.meta.json. Agrega metadata de gobernanza para versionar responsables y cambios.");
+    }
+    return emptyResult;
+  }
+  try {
+    const raw = fs.readFileSync(metadataPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const metadata = {
+      path: metadataPath,
+      exists: true,
+      isValid: true,
+      enforcementMode: getQaContextGovernanceMode(),
+      version: asTrimmedString(parsed?.version),
+      updatedBy: asTrimmedString(parsed?.updated_by ?? parsed?.updatedBy),
+      approvedBy: asTrimmedString(parsed?.approved_by ?? parsed?.approvedBy),
+      ownerTeam: asTrimmedString(parsed?.owner_team ?? parsed?.ownerTeam),
+      changeSummary: asTrimmedString(parsed?.change_summary ?? parsed?.changeSummary),
+      effectiveFrom: asTrimmedString(parsed?.effective_from ?? parsed?.effectiveFrom),
+      tags: asStringList(parsed?.tags),
+      warnings
+    };
+    if (!metadata.version)
+      warnings.push('qa-context.meta.json no define "version".');
+    if (!metadata.updatedBy)
+      warnings.push('qa-context.meta.json no define "updated_by".');
+    if (!metadata.ownerTeam)
+      warnings.push('qa-context.meta.json no define "owner_team".');
+    if (!metadata.changeSummary)
+      warnings.push('qa-context.meta.json no define "change_summary".');
+    metadata.isValid = warnings.length === 0;
+    return metadata;
+  } catch (error) {
+    warnings.push("qa-context.meta.json no se pudo leer o parsear correctamente.");
+    return {
+      ...emptyResult,
+      exists: true,
+      warnings
+    };
+  }
+}
+function getQaContextGovernanceMode() {
+  const raw = String(process.env.ARCALITY_QA_CONTEXT_GOVERNANCE || "").trim().toLowerCase();
+  if (raw === "off")
+    return "off";
+  if (raw === "strict" || raw === "enforce" || raw === "required")
+    return "strict";
+  if (raw === "warn")
+    return "warn";
+  if (process.env.CI === "true")
+    return "strict";
+  return "warn";
+}
+function getQaContextGovernanceIssues(analysis) {
+  if (!analysis.exists)
+    return [];
+  const issues = [];
+  if (!analysis.governance.exists) {
+    issues.push("Falta el archivo .arcality/qa-context.meta.json para gobernanza del contexto.");
+    return issues;
+  }
+  if (!analysis.governance.version)
+    issues.push("La metadata no define version.");
+  if (!analysis.governance.updatedBy)
+    issues.push("La metadata no define updated_by.");
+  if (!analysis.governance.ownerTeam)
+    issues.push("La metadata no define owner_team.");
+  if (!analysis.governance.changeSummary)
+    issues.push("La metadata no define change_summary.");
+  return issues;
+}
+function shouldBlockOnQaContextGovernance(analysis) {
+  const mode = analysis.governance.enforcementMode;
+  if (mode !== "strict")
+    return false;
+  return getQaContextGovernanceIssues(analysis).length > 0;
+}
 function analyzeQaContext(projectRoot = process.cwd()) {
   const filePath = path.join(projectRoot, ".arcality", "qa-context.md");
   const emptyResult = {
@@ -1311,7 +1825,12 @@ function analyzeQaContext(projectRoot = process.cwd()) {
     ruleCount: 0,
     sectionCount: 0,
     recognizedSectionCount: 0,
+    unrecognizedSectionCount: 0,
     ignoredExampleCount: 0,
+    duplicateRuleCount: 0,
+    lastModifiedAt: null,
+    fingerprint: null,
+    governance: loadQaContextGovernance(projectRoot, false),
     warnings: [],
     status: "missing",
     isValid: false
@@ -1320,12 +1839,16 @@ function analyzeQaContext(projectRoot = process.cwd()) {
     return emptyResult;
   }
   const rawContent = fs.readFileSync(filePath, "utf8");
+  const stat = fs.statSync(filePath);
   const cleanedContent = stripHtmlComments(rawContent);
   const lines = cleanedContent.split(/\r?\n/);
-  const warnings = [];
+  const governance = loadQaContextGovernance(projectRoot, true);
+  const warnings = [...governance.warnings];
   const sections = [];
   let currentSection = null;
   let ignoredExampleCount = 0;
+  let duplicateRuleCount = 0;
+  const seenRules = /* @__PURE__ */ new Set();
   const openSection = (title) => {
     currentSection = {
       title: title.trim(),
@@ -1352,6 +1875,12 @@ function analyzeQaContext(projectRoot = process.cwd()) {
       ignoredExampleCount += 1;
       continue;
     }
+    const dedupeKey = rule.toLowerCase();
+    if (seenRules.has(dedupeKey)) {
+      duplicateRuleCount += 1;
+      continue;
+    }
+    seenRules.add(dedupeKey);
     if (currentSection) {
       currentSection.rules.push(rule);
     }
@@ -1359,6 +1888,7 @@ function analyzeQaContext(projectRoot = process.cwd()) {
   const nonEmptySections = sections.filter((section) => section.rules.length > 0);
   const ruleCount = nonEmptySections.reduce((total, section) => total + section.rules.length, 0);
   const recognizedSectionCount = nonEmptySections.filter((section) => section.recognized).length;
+  const unrecognizedSectionCount = nonEmptySections.length - recognizedSectionCount;
   if (!rawContent.trim()) {
     warnings.push("El archivo existe pero esta vacio.");
   }
@@ -1375,6 +1905,12 @@ function analyzeQaContext(projectRoot = process.cwd()) {
   if (ruleCount > 0 && recognizedSectionCount === 0) {
     warnings.push("Hay reglas, pero ninguna cae en las secciones sugeridas. Revisa la estructura del archivo.");
   }
+  if (duplicateRuleCount > 0) {
+    warnings.push(`Se omitieron ${duplicateRuleCount} regla(s) duplicadas del QA Context.`);
+  }
+  if (unrecognizedSectionCount > 0) {
+    warnings.push(`Hay ${unrecognizedSectionCount} seccion(es) con reglas que no coinciden con la taxonomia sugerida.`);
+  }
   const sanitizedContent = nonEmptySections.map((section) => {
     const rules = section.rules.map((rule) => `- ${rule}`).join("\n");
     return `## ${section.title}
@@ -1396,7 +1932,12 @@ ${rules}`;
     ruleCount,
     sectionCount: nonEmptySections.length,
     recognizedSectionCount,
+    unrecognizedSectionCount,
     ignoredExampleCount,
+    duplicateRuleCount,
+    lastModifiedAt: stat.mtime.toISOString(),
+    fingerprint: `${stat.size}:${stat.mtimeMs}`,
+    governance,
     warnings,
     status,
     isValid: ruleCount > 0
@@ -1414,10 +1955,28 @@ function formatQaContextSummary(analysis) {
   lines.push("QA Context Summary");
   lines.push(`Status: ${analysis.status}`);
   lines.push(`Path: ${analysis.filePath}`);
+  lines.push(`Priority: local qa-context > backend collective memory > base heuristics`);
   lines.push(`Rules loaded: ${analysis.ruleCount}`);
   lines.push(`Sections with rules: ${analysis.sectionCount}`);
   lines.push(`Recognized sections: ${analysis.recognizedSectionCount}`);
+  lines.push(`Unrecognized sections: ${analysis.unrecognizedSectionCount}`);
   lines.push(`Ignored examples/placeholders: ${analysis.ignoredExampleCount}`);
+  lines.push(`Duplicate rules removed: ${analysis.duplicateRuleCount}`);
+  lines.push(`Last modified: ${analysis.lastModifiedAt || "N/A"}`);
+  lines.push(`Fingerprint: ${analysis.fingerprint || "N/A"}`);
+  lines.push(`Governance metadata: ${analysis.governance.exists ? analysis.governance.isValid ? "valid" : "warning" : "missing"}`);
+  lines.push(`Governance enforcement: ${analysis.governance.enforcementMode}`);
+  if (analysis.governance.exists) {
+    lines.push("");
+    lines.push("Governance metadata:");
+    lines.push(`- Version: ${analysis.governance.version || "N/A"}`);
+    lines.push(`- Updated by: ${analysis.governance.updatedBy || "N/A"}`);
+    lines.push(`- Approved by: ${analysis.governance.approvedBy || "N/A"}`);
+    lines.push(`- Owner team: ${analysis.governance.ownerTeam || "N/A"}`);
+    lines.push(`- Effective from: ${analysis.governance.effectiveFrom || "N/A"}`);
+    lines.push(`- Change summary: ${analysis.governance.changeSummary || "N/A"}`);
+    lines.push(`- Tags: ${analysis.governance.tags.length > 0 ? analysis.governance.tags.join(", ") : "N/A"}`);
+  }
   if (analysis.sections.length > 0) {
     lines.push("");
     lines.push("Sections applied:");
@@ -1432,36 +1991,106 @@ function formatQaContextSummary(analysis) {
       lines.push(`- ${warning}`);
     }
   }
+  const governanceIssues = getQaContextGovernanceIssues(analysis);
+  if (governanceIssues.length > 0) {
+    lines.push("");
+    lines.push("Governance issues:");
+    for (const issue of governanceIssues) {
+      lines.push(`- ${issue}`);
+    }
+  }
   if (!analysis.exists) {
     lines.push("");
     lines.push("No local QA Context file was found for this mission.");
   }
   return lines.join("\n");
 }
+function buildEffectiveContextBlock(params) {
+  const { localAnalysis, localPromptBlock, backendContext } = params;
+  const backendRules = backendContext?.rules || [];
+  const backendFields = backendContext?.fields || [];
+  const blocks = [];
+  if (localPromptBlock) {
+    const governanceLines = [
+      `Version: ${localAnalysis.governance.version || "N/A"}`,
+      `Updated by: ${localAnalysis.governance.updatedBy || "N/A"}`,
+      `Approved by: ${localAnalysis.governance.approvedBy || "N/A"}`,
+      `Owner team: ${localAnalysis.governance.ownerTeam || "N/A"}`,
+      `Change summary: ${localAnalysis.governance.changeSummary || "N/A"}`
+    ].join("\n");
+    blocks.push(
+      `<LOCAL_QA_CONTEXT>
+Priority: Highest.
+If any local rule conflicts with backend collective memory, follow the local rule.
+Governance metadata:
+${governanceLines}
+${localPromptBlock}
+</LOCAL_QA_CONTEXT>`
+    );
+  }
+  if (backendRules.length > 0 || backendFields.length > 0) {
+    const backendLines = [];
+    backendLines.push(`<BACKEND_COLLECTIVE_MEMORY>`);
+    backendLines.push(`Priority: Secondary. Use this when local qa-context does not define the rule explicitly.`);
+    if (backendRules.length > 0) {
+      backendLines.push(`Rules:`);
+      for (const rule of backendRules) {
+        backendLines.push(`- [${rule.severity}] ${rule.title}: ${rule.description}`);
+      }
+    }
+    if (backendFields.length > 0) {
+      backendLines.push(`Known fields:`);
+      for (const field of backendFields) {
+        backendLines.push(`- ${field.field_identifier} (${field.field_type}) - Required: ${field.is_required}`);
+      }
+    }
+    backendLines.push(`</BACKEND_COLLECTIVE_MEMORY>`);
+    blocks.push(backendLines.join("\n"));
+  }
+  if (blocks.length === 0)
+    return "";
+  return `
+<CUSTOMER_CONTEXT_POLICY>
+Use customer context with this precedence order:
+1. Local qa-context file
+2. Backend collective memory
+3. Base QA heuristics
+Never ignore a valid local qa-context rule because of a conflicting backend memory entry.
+Local context status: ${localAnalysis.status}
+Local context fingerprint: ${localAnalysis.fingerprint || "N/A"}
+</CUSTOMER_CONTEXT_POLICY>
+
+` + blocks.join("\n\n") + `
+`;
+}
 
 // tests/_helpers/ai-agent-helper.ts
 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"]
     }
   },
   {
@@ -1490,7 +2119,7 @@ var AIAgentHelper = class {
   qaContextAnalysisCache = null;
   qaContextPromptCache = "";
   qaContextStatusLogged = false;
-  constructor(page, contextDir = "out", testInfo, knowledgeService) {
+  constructor(page, contextDir, testInfo, knowledgeService) {
     this.page = page;
     this.contextDir = contextDir;
     this.testInfo = testInfo;
@@ -1551,29 +2180,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 +2225,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 +2592,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 +2748,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 +2925,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,10 +2944,17 @@ ${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");
-      const ctx = getProjectContext(process.cwd());
+      const runtimeProjectRoot = process.env.ARCALITY_PROJECT_ROOT || process.cwd();
+      const ctx = getProjectContext(runtimeProjectRoot);
       projectInfo = `
 \u{1F3D7}\uFE0F PROJECT CONTEXT:
 - Name: ${ctx.name}
@@ -2235,51 +2964,22 @@ ${relevantFailures.map((m) => `- ${m.prompt}`).join("\n")}
 `;
     } catch {
     }
-    let memoryBackendContext = "";
+    let backendContextData = null;
     try {
-      const contextData = await this.knowledgeService.getContext(state.url);
-      if (contextData && (contextData.rules?.length > 0 || contextData.fields?.length > 0)) {
-        memoryBackendContext = `
-\u{1F9E0} BACKEND COLLECTIVE MEMORY FOR THIS PAGE:
-`;
-        if (contextData.rules?.length > 0) {
-          memoryBackendContext += `BUSINESS RULES:
-`;
-          contextData.rules.forEach((r) => memoryBackendContext += `- [${r.severity}] ${r.title}: ${r.description}
-`);
-        }
-        if (contextData.fields?.length > 0) {
-          memoryBackendContext += `KNOWN FIELDS:
-`;
-          contextData.fields.forEach((f) => memoryBackendContext += `- ${f.field_identifier} (${f.field_type}) - Required: ${f.is_required}
-`);
-        }
+      backendContextData = await this.knowledgeService.getContext(state.url);
+      if (backendContextData && (backendContextData.rules?.length > 0 || backendContextData.fields?.length > 0)) {
         if (process.env.DEBUG)
-          console.log(`>>ARCALITY_STATUS>> \u{1F9E0} Contexto de Memoria Colectiva inyectado (${contextData.rules?.length || 0} reglas, ${contextData.fields?.length || 0} campos).`);
+          console.log(`>>ARCALITY_STATUS>> \u{1F9E0} Contexto de Memoria Colectiva inyectado (${backendContextData.rules?.length || 0} reglas, ${backendContextData.fields?.length || 0} campos).`);
       }
     } catch (e) {
       if (process.env.DEBUG)
         console.log(`>>ARCALITY_STATUS>> \u26A0\uFE0F Error en hook de contexto: ${e.message}`);
     }
     let customUserContext = "";
-    try {
-      const fs6 = require("fs");
-      const path6 = require("path");
-      const customContextPath = path6.join(process.cwd(), ".arcality", "qa-context.md");
-      if (false) {
-        const content = fs6.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:
-${content}
-</CUSTOMER_BUSINESS_RULES>
-`;
-      }
-    } catch (e) {
-    }
     try {
       if (!this.qaContextAnalysisCache) {
-        const qaContextState = loadQaContextForPrompt(process.cwd());
+        const runtimeProjectRoot = process.env.ARCALITY_PROJECT_ROOT || process.cwd();
+        const qaContextState = loadQaContextForPrompt(runtimeProjectRoot);
         this.qaContextAnalysisCache = qaContextState.analysis;
         this.qaContextPromptCache = qaContextState.promptBlock;
       }
@@ -2295,18 +2995,16 @@ ${content}
             console.log(`>>ARCALITY_STATUS>> QA Context warning: ${warning}`);
           }
         }
+        if (qaContextAnalysis.exists || backendContextData?.rules?.length || backendContextData?.fields?.length) {
+          console.log(`>>ARCALITY_STATUS>> Pol\xEDtica efectiva de contexto: local qa-context > memoria backend > heur\xEDsticas base.`);
+        }
         this.qaContextStatusLogged = true;
       }
-      if (this.qaContextPromptCache) {
-        customUserContext = `
-<CUSTOMER_BUSINESS_RULES>
-El Ing. de QA o Cliente final ha provisto reglas locales para este negocio/dominio. Debes priorizar esta informacion sobre tus heuristicas base cuando exista conflicto.
-${this.qaContextPromptCache}
-</CUSTOMER_BUSINESS_RULES>
-`;
-      } else {
-        customUserContext = "";
-      }
+      customUserContext = buildEffectiveContextBlock({
+        localAnalysis: qaContextAnalysis,
+        localPromptBlock: this.qaContextPromptCache,
+        backendContext: backendContextData
+      });
     } catch (e) {
     }
     const systemPromptBlocks = [
@@ -2315,15 +3013,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",
@@ -2377,6 +3067,7 @@ These are NOT optional. You MUST use these tools in these situations:
 | Bug found in application | \`create_test_evidence\` | To document with annotated screenshot |
 | Mission complete | \`create_test_evidence\` | To document the final successful state |
 | Modal/popup blocking page | \`send_keyboard_event\` (Escape) | To close the overlay |
+| Masked numeric/code input, OTP/PIN/CLABE/INE identifier, or prompt says "manualmente", "d\xEDgito por d\xEDgito", "car\xE1cter por car\xE1cter" | \`type_sequentially\` | After ONE focus attempt on the field; do not keep clicking |
 | Time/Date/Color picker field | \`interact_native_control\` | INSTEAD of fill \u2014 native inputs need special handling |
 | Element not found on screen | \`scroll_page\` | To reveal off-screen content |
 | Need to close dropdown/menu | \`send_keyboard_event\` (Escape) | IMMEDIATELY after selecting any option \u2014 MANDATORY |
@@ -2421,6 +3112,19 @@ 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. **MASKED / SEQUENTIAL INPUTS (MANDATORY PROTOCOL)**: If the field is a masked identifier/code input (examples: placeholders like \`000-000-000-0000\`, OTP/PIN boxes, CLABE/account identifiers, ID/INE codes) OR the mission explicitly says "manualmente", "n\xFAmero por n\xFAmero", "d\xEDgito por d\xEDgito", or "car\xE1cter por car\xE1cter":
+   - You get EXACTLY ONE focus attempt: click the field once, or click a nearby keyboard button/icon ONCE if the UI shows one (e.g. "Teclado").
+   - Then you MUST use \`type_sequentially\` with the full string. Do NOT simulate manual typing by repeatedly clicking the field.
+   - If the field still does not accept input after that, use \`inspect_element_details\` on the field or the adjacent keyboard trigger. Never click the same input 3+ times in a row.
+   - For numeric codes, preserve exact length. Count the digits from the mission and type all of them.
+
+16. **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 +3164,23 @@ 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. **SEQUENTIAL CODE INPUT FALLBACK (CRITICAL)**: If you are on a code/identifier step and the UI shows a field like "Identificador", an adjacent "Teclado" button, or a mask such as \`000-000-000-0000\`, NEVER spend multiple turns trying to focus the field. One click is enough. After that, use \`type_sequentially\` with the complete code string. If the keyboard button exists and the first direct focus did not work, click the keyboard button ONCE and then use \`type_sequentially\`.
+
+13. **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}
+${assetContext}`
       }
     ];
     if (this.testInfo) {
@@ -2544,11 +3264,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 +3287,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 +3602,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 +3614,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)
@@ -3041,6 +3758,45 @@ ${report}` });
           } catch (e) {
             toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Error sending key: ${e.message}` });
           }
+        } else if (toolName === "type_sequentially") {
+          const { idx, text, delay_ms = 80, clear_first = true } = toolInput;
+          console.log(`>>ARCALITY_STATUS>> \u2328\uFE0F\u270D\uFE0F Type sequentially IDX:${idx} \u2192 "${text}"`);
+          const c = state.components.find((comp) => comp.idx === idx);
+          if (!c) {
+            toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: "Element not found." });
+          } else {
+            try {
+              const frame = this.page.frames()[c.frameIdx];
+              const loc = frame.locator(c.selector).first();
+              await loc.scrollIntoViewIfNeeded({ timeout: 5e3 }).catch(() => {
+              });
+              await loc.focus({ timeout: 3e3 }).catch(async () => {
+                await loc.click({ timeout: 5e3, force: true });
+              });
+              if (clear_first) {
+                await this.page.keyboard.press("Control+a").catch(() => {
+                });
+                await this.page.keyboard.press("Delete").catch(() => {
+                });
+                await this.page.waitForTimeout(100);
+              }
+              await this.page.keyboard.type(String(text), { delay: Math.max(10, Math.min(Number(delay_ms) || 80, 400)) });
+              const finalValue = await loc.evaluate((el) => {
+                if (typeof el.value === "string")
+                  return el.value;
+                if (el.isContentEditable)
+                  return el.innerText || "";
+                return document.activeElement?.value || "";
+              }).catch(() => "");
+              toolResults.push({
+                type: "tool_result",
+                tool_use_id: toolUse.id,
+                content: `\u2705 Sequential typing completed. Current value: "${finalValue}".`
+              });
+            } catch (e) {
+              toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Error typing sequentially: ${e.message}` });
+            }
+          }
         } else if (toolName === "interact_native_control") {
           const { idx, control_type, value } = toolInput;
           const c = state.components.find((comp) => comp.idx === idx);
@@ -3423,9 +4179,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();
@@ -3450,16 +4207,43 @@ async function readLocatorText(locator) {
   const innerText = await locator.innerText().catch(() => "");
   return typeof innerText === "string" ? innerText.trim() : "";
 }
+async function readHiddenPortalResult(page) {
+  const selectors = [
+    "input#result",
+    'input[name="result"]',
+    'input[readonly][id*="result" i]',
+    'input[readonly][name*="result" i]'
+  ];
+  for (const selector of selectors) {
+    try {
+      const locator = page.locator(selector).first();
+      if (!await locator.count().catch(() => 0))
+        continue;
+      const rawValue = await locator.inputValue().catch(async () => await locator.getAttribute("value"));
+      const raw = typeof rawValue === "string" ? rawValue.trim() : "";
+      if (!raw)
+        continue;
+      const parsed = JSON.parse(raw);
+      const status = String(parsed?.status || parsed?.Status || "").trim().toLowerCase();
+      const message = String(parsed?.message || parsed?.Message || parsed?.detail || parsed?.error || "").trim();
+      if (status) {
+        return { status, message, raw };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
 function writeBatchMissionResult(payload) {
   const runDomainDir = process.env.ARCALITY_RUN_DOMAIN_DIR;
   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 {
@@ -3467,7 +4251,10 @@ function writeBatchMissionResult(payload) {
 }
 (0, import_test.test)("Arcality AI Runner", async ({ page }, testInfo) => {
   import_test.test.setTimeout(12e5);
-  const contextDir = process.env.CONTEXT_DIR || "out";
+  const contextDir = process.env.CONTEXT_DIR;
+  if (!contextDir) {
+    throw new Error("Missing CONTEXT_DIR. Arcality must run through the CLI wrapper so outputs stay inside the user project .arcality directory.");
+  }
   const activeConfig = process.env.ACTIVE_CONFIG || "Default";
   if (!process.env.BASE_URL && process.env[`${activeConfig}_URL`])
     process.env.BASE_URL = process.env[`${activeConfig}_URL`];
@@ -3480,16 +4267,22 @@ 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 {
     }
   }
   const agent = new AIAgentHelper(page, contextDir, testInfo);
   const prompt = process.env.SMART_PROMPT || "Navega al inicio y verifica que el sitio cargue";
-  const qaContextAnalysis = analyzeQaContext(process.cwd());
+  const runtimeProjectRoot = process.env.ARCALITY_PROJECT_ROOT || process.cwd();
+  const qaContextAnalysis = analyzeQaContext(runtimeProjectRoot);
   if (qaContextAnalysis.exists && qaContextAnalysis.isValid) {
     console.log(`>>ARCALITY_STATUS>> QA Context validado al arranque (${qaContextAnalysis.ruleCount} reglas, ${qaContextAnalysis.sectionCount} secciones).`);
   } else if (qaContextAnalysis.exists) {
@@ -3500,10 +4293,24 @@ function writeBatchMissionResult(payload) {
   } else {
     console.log(`>>ARCALITY_STATUS>> QA Context local no configurado para esta mision.`);
   }
+  if (qaContextAnalysis.governance.exists) {
+    console.log(`>>ARCALITY_STATUS>> QA Context metadata: version=${qaContextAnalysis.governance.version || "N/A"} | updated_by=${qaContextAnalysis.governance.updatedBy || "N/A"} | owner_team=${qaContextAnalysis.governance.ownerTeam || "N/A"}`);
+  }
   await testInfo.attach("qa_context_summary", {
     body: Buffer.from(formatQaContextSummary(qaContextAnalysis), "utf-8"),
     contentType: "text/plain"
   });
+  const governanceIssues = getQaContextGovernanceIssues(qaContextAnalysis);
+  if (governanceIssues.length > 0) {
+    for (const issue of governanceIssues) {
+      console.log(`>>ARCALITY_STATUS>> QA Context governance issue: ${issue}`);
+    }
+  }
+  if (shouldBlockOnQaContextGovernance(qaContextAnalysis)) {
+    throw new Error(
+      `QA Context governance is required for this run (${qaContextAnalysis.governance.enforcementMode}) and is incomplete. Fix .arcality/qa-context.meta.json before continuing.`
+    );
+  }
   const successKeywords = /exitosamente|creado correctamente|guardado correctamente|misión cumplida|registered successfully|created successfully|saved successfully|operación exitosa|registro guardado|successfully|correctly/i;
   const failureKeywords = /\berror\b|falló|failed|no se puede|cannot|unable|ya existe|already exists|existente|exist|inválido|invalid|incorrecto|incorrect|ligado|linked|depende|depends|duplicado|duplicate|repetido|repeated|conflict|reintentar|retry|missing|required|obligatorio|bad request|400|500/i;
   const systemErrorKeywords = /error interno|internal error|intentarlo más tarde|try again later|inténtelo más tarde|servicio no disponible|service unavailable|something went wrong|algo salió mal|ha ocurrido un error inesperado|unexpected error|server error|no se pudo procesar|could not be processed|comuníquese con soporte|contact support/i;
@@ -3522,18 +4329,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 +4427,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 +4448,29 @@ 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;
+      if (!runDomainDir) {
+        throw new Error("Missing ARCALITY_RUN_DOMAIN_DIR. Arcality must run through the CLI wrapper so durable logs stay inside the user project .arcality directory.");
+      }
+      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 +4480,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) {
@@ -3667,9 +4498,11 @@ function writeBatchMissionResult(payload) {
     const pid = process.env.ARCALITY_PROJECT_ID || "";
     const apiUrl = process.env.ARCALITY_API_URL || "";
     const apiKey = process.env.ARCALITY_API_KEY || "";
-    if (!pid || !apiUrl || !apiKey) {
+    const orgId = process.env.ARCALITY_ORG_ID || "";
+    if (!pid || !apiUrl || !apiKey || !orgId) {
+      console.log(`>>ARCALITY_STATUS>> \u{1F9E0} Memoria Colectiva omitida por configuraci\xF3n incompleta.`);
       if (process.env.DEBUG)
-        console.warn(`[CollectiveMemory] \u26A0\uFE0F Vars faltantes \u2014 project_id='${pid}' api_url='${apiUrl}' api_key='${apiKey ? "OK" : "MISSING"}' \u2192 NO persiste.`);
+        console.warn(`[CollectiveMemory] \u26A0\uFE0F Vars faltantes \u2014 project_id='${pid}' api_url='${apiUrl}' api_key='${apiKey ? "OK" : "MISSING"}' org_id='${orgId || "MISSING"}' \u2192 NO persiste.`);
       return;
     }
     if (collectiveMemoryPersisted && !isFailed) {
@@ -3816,8 +4649,7 @@ function writeBatchMissionResult(payload) {
       const matches = promptKeywords.filter((kw) => patternKeywords.some((pkw) => pkw.includes(kw) || kw.includes(pkw))).length;
       const isVectorMatch = true;
       if (isVectorMatch) {
-        if (process.env.DEBUG)
-          console.log(`>>ARCALITY_STATUS>> \u{1F9E0} Memoria Colectiva detectada (id: ${bestMatch.id}). Descargando a memoria local...`);
+        console.log(`>>ARCALITY_STATUS>> \u{1F9E0} Memoria Colectiva detectada (id: ${bestMatch.id}). Descargando a memoria local...`);
         reusedPatternId = bestMatch.id || "unknown";
         let patternJsonObj = {};
         try {
@@ -3849,11 +4681,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 +4697,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.`);
@@ -4054,6 +4886,35 @@ Detalles de la excepci\xF3n en consola: ${jsError}`;
     }
     if (isFinished)
       break;
+    try {
+      const hiddenResult = await readHiddenPortalResult(page);
+      if (hiddenResult) {
+        const hiddenStatus = hiddenResult.status.toLowerCase();
+        const hiddenMessage = hiddenResult.message || hiddenResult.raw;
+        if (/^(failed|error|invalid|rejected)$/.test(hiddenStatus)) {
+          console.log(`>>ARCALITY_STATUS>> \u26A0\uFE0F Resultado oculto detectado: "${hiddenStatus}" - ${hiddenMessage.substring(0, 120)}`);
+          hasCriticalError = true;
+          failReason = "portal_hidden_result_error";
+          failReasoning = `El portal public\xF3 un resultado interno oculto indicando fallo: "${hiddenMessage}". Arcality detuvo la misi\xF3n para evitar loops sobre una operaci\xF3n ya rechazada.`;
+          aiMarkedSuccess = false;
+          isFinished = true;
+          history.push(`Turno ${stepCount}: \u{1F6D1} [HIDDEN_RESULT_ERROR] El portal devolvi\xF3 status="${hiddenStatus}" con mensaje "${hiddenMessage.substring(0, 200)}".`);
+          saveMissionResults();
+          break;
+        }
+        if (/^(success|succeeded|ok|completed)$/.test(hiddenStatus)) {
+          console.log(`>>ARCALITY_STATUS>> \u2728 Resultado oculto de \xE9xito detectado: "${hiddenStatus}"`);
+          aiMarkedSuccess = true;
+          hasCriticalError = false;
+          isFinished = true;
+          history.push(`Turno ${stepCount}: \u2705 [HIDDEN_RESULT_SUCCESS] El portal devolvi\xF3 status="${hiddenStatus}".`);
+          await persistCollectiveMemory();
+          saveMissionResults();
+          break;
+        }
+      }
+    } catch {
+    }
     let hasVisibleError = false;
     try {
       const errorEls = await page.locator('.toast, .alert, [role="alert"], [role="status"], .snackbar, .notification, .error-message, .mat-snack-bar-container, [class*="alert"], [class*="toast"]').all();
@@ -4142,7 +5003,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) {
@@ -4198,7 +5068,7 @@ ${patternContext}` : prompt;
         const loopType = isClickLoop ? "click" : "fill";
         const uniqueTargets = isClickLoop ? uniqueClicks : uniqueFills;
         console.warn(`
-\u26A0 [OUROBOROS SUBSYSTEM: Repetitive ${loopType} loop anomaly detected]:`);
+\u26A0 Bucle repetitivo de ${loopType} detectado:`);
         console.warn(`   \xDAltimas acciones: ${lastActions.join(" \u2192 ")}`);
         response.thought = `\u{1F6D1} ERROR: Bucle repetitivo en ${loopType} sobre: ${Array.from(uniqueTargets).join(", ")}.`;
         response.finish = true;
@@ -4216,7 +5086,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();
@@ -4315,7 +5185,7 @@ Acci\xF3n bloqueada: Bucle de tipo ${loopType} sobre los elementos ${Array.from(
                 }
                 console.log(`
 \u{1F6D1} [AUTO-STOP] Bloqueando click repetido en "${desc}" (${sameActionCount} veces). Forzando re-evaluaci\xF3n.`);
-                history.push(`Turno ${stepCount}: \u{1F6D1} [AUTO-STOP] El click en "${desc}" fue bloqueado despu\xE9s de ${sameActionCount} repeticiones. Si es un dropdown/combobox que no abre sus opciones, usa send_keyboard_event con key "ArrowDown" para navegar opciones y "Enter" para seleccionar. NO vuelvas a hacer click en el mismo elemento.`);
+                history.push(`Turno ${stepCount}: \u{1F6D1} [AUTO-STOP] El click en "${desc}" fue bloqueado despu\xE9s de ${sameActionCount} repeticiones. Si es un dropdown/combobox que no abre sus opciones, usa send_keyboard_event con key "ArrowDown" y luego "Enter". Si es un input enmascarado o un c\xF3digo/identificador, usa type_sequentially con el valor completo despu\xE9s de UN solo enfoque. NO vuelvas a hacer click en el mismo elemento.`);
                 await page.waitForTimeout(800);
                 break;
               }
@@ -4431,12 +5301,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 +5363,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 +5647,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 +5702,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 +5750,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}`);