@arcadialdev/arcality 4.0.2 → 4.1.1

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

@@ -39,7 +39,7 @@ __export(asset_resolver_exports, {
   syncAssetsFromBackend: () => syncAssetsFromBackend
 });
 function readJsonFile(filePath) {
-  const raw = fs2.readFileSync(filePath, "utf8").trim();
+  const raw = fs3.readFileSync(filePath, "utf8").trim();
   if (!raw)
     return null;
   return JSON.parse(raw);
@@ -48,7 +48,7 @@ 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();
+  const ext = path4.extname(filePath || "").toLowerCase();
   if (ext === ".jpg" || ext === ".jpeg")
     return "image/jpeg";
   if (ext === ".webp")
@@ -72,16 +72,16 @@ function inferAssetType(...values) {
 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 filename = String(raw.filename || raw.fileName || (rawPath ? path4.basename(rawPath) : "") || "").trim();
+  const derivedId = filename ? `asset_${sanitizeIdPart(path4.basename(filename, path4.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;
+  if (filePath && !path4.isAbsolute(filePath)) {
+    const cwdCandidate = path4.resolve(process.cwd(), filePath);
+    const assetDirCandidate = assetsDir ? path4.resolve(assetsDir, filePath) : "";
+    filePath = fs3.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();
@@ -99,14 +99,14 @@ function normalizeAsset(raw, assetsDir = null) {
   };
 }
 function getDefaultAssetsDir() {
-  return process.env.ARCALITY_ASSETS_DIR || path2.join(process.cwd(), ".arcality", "assets");
+  return process.env.ARCALITY_ASSETS_DIR || path4.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 manifestPath = explicitFile || path4.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 parsed = inlineJson ? JSON.parse(inlineJson) : fs3.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) {
@@ -116,13 +116,13 @@ function loadManifestAssets(assetsDir) {
 }
 function scanAssetsDir(assetsDir) {
   try {
-    if (!fs2.existsSync(assetsDir))
+    if (!fs3.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 fs3.readdirSync(assetsDir, { withFileTypes: true }).filter((entry) => entry.isFile() && IMAGE_EXTENSIONS.has(path4.extname(entry.name).toLowerCase())).map((entry) => {
+      const filePath = path4.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, " "),
+        id: `asset_${sanitizeIdPart(path4.basename(entry.name, path4.extname(entry.name)))}`,
+        label: path4.basename(entry.name, path4.extname(entry.name)).replace(/[_-]+/g, " "),
         path: filePath,
         mime: normalizeMimeFromPath(filePath),
         type: inferAssetType(entry.name)
@@ -247,7 +247,7 @@ function resolveUploadAsset(value, label = "file upload") {
     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)) {
+    if (matchingAsset?.filePath && fs3.existsSync(matchingAsset.filePath)) {
       console.log(`>>ARCALITY_STATUS>> Usando asset real configurado para el placeholder "${raw}": ${matchingAsset.filePath}`);
       return matchingAsset.filePath;
     }
@@ -255,14 +255,14 @@ function resolveUploadAsset(value, label = "file upload") {
   }
   if (/^arcasset:\/\//i.test(raw) || /^asset_[a-z0-9_-]+$/i.test(raw)) {
     const asset = findAsset(raw);
-    if (asset?.filePath && fs2.existsSync(asset.filePath)) {
+    if (asset?.filePath && fs3.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)) {
+  const filePath = path4.isAbsolute(raw) ? raw : path4.resolve(process.cwd(), raw);
+  if (fs3.existsSync(filePath)) {
     return filePath;
   }
   console.warn(`>>ARCALITY_STATUS>> Archivo de upload no encontrado: "${raw}". Usando placeholder.`);
@@ -278,8 +278,8 @@ async function syncAssetsFromBackend() {
   }
   try {
     const assetsDir = getDefaultAssetsDir();
-    if (!fs2.existsSync(assetsDir)) {
-      fs2.mkdirSync(assetsDir, { recursive: true });
+    if (!fs3.existsSync(assetsDir)) {
+      fs3.mkdirSync(assetsDir, { recursive: true });
     }
     const url = `${apiUrl}/api/v1/projects/${projectId}/assets`;
     console.log(`>>ARCALITY_STATUS>> \u{1F4E6} Consultando assets configurados del proyecto...`);
@@ -314,14 +314,14 @@ async function syncAssetsFromBackend() {
         continue;
       }
       const prefix = `${assetId}_`;
-      const files = fs2.existsSync(assetsDir) ? fs2.readdirSync(assetsDir) : [];
+      const files = fs3.existsSync(assetsDir) ? fs3.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) {
+        const candidatePath = path4.join(assetsDir, existingFile);
+        if (fs3.existsSync(candidatePath) && fs3.statSync(candidatePath).size > 0) {
           filename = filename || existingFile.substring(prefix.length);
           localFilePath = candidatePath;
           downloadNeeded = false;
@@ -342,13 +342,13 @@ async function syncAssetsFromBackend() {
           const matFilename = matData.filename || matData.fileName || filename || `${assetId}.png`;
           filename = matFilename;
           const localFilename = `${assetId}_${matFilename}`;
-          localFilePath = path2.join(assetsDir, localFilename);
+          localFilePath = path4.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);
+              fs3.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}`);
@@ -357,7 +357,7 @@ async function syncAssetsFromBackend() {
         } else {
           console.warn(`>>ARCALITY_STATUS>> \u26A0\uFE0F Error al materializar asset: ${matRes.status}`);
           filename = filename || `${assetId}.png`;
-          localFilePath = path2.join(assetsDir, `${assetId}_${filename}`);
+          localFilePath = path4.join(assetsDir, `${assetId}_${filename}`);
         }
       }
       localAssets.push({
@@ -373,12 +373,12 @@ async function syncAssetsFromBackend() {
         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 });
+    const manifestPath = process.env.ARCALITY_ASSETS_FILE || path4.join(process.cwd(), ".arcality", "assets.json");
+    const manifestDir = path4.dirname(manifestPath);
+    if (!fs3.existsSync(manifestDir)) {
+      fs3.mkdirSync(manifestDir, { recursive: true });
     }
-    fs2.writeFileSync(manifestPath, JSON.stringify(localAssets, null, 2), "utf8");
+    fs3.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}`);
@@ -387,11 +387,11 @@ async function syncAssetsFromBackend() {
     console.warn(`>>ARCALITY_STATUS>> \u26A0\uFE0F Error durante la sincronizaci\xF3n de assets: ${e.message}`);
   }
 }
-var fs2, path2, zlib, IMAGE_EXTENSIONS;
+var fs3, path4, zlib, IMAGE_EXTENSIONS;
 var init_asset_resolver = __esm({
   "tests/_helpers/asset-resolver.ts"() {
-    fs2 = __toESM(require("fs"));
-    path2 = __toESM(require("path"));
+    fs3 = __toESM(require("fs"));
+    path4 = __toESM(require("path"));
     zlib = __toESM(require("zlib"));
     IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp"]);
   }
@@ -1072,6 +1072,156 @@ var scrollPageTool = {
     required: ["direction"]
   }
 };
+var validateDatabaseStateTool = {
+  name: "validate_database_state",
+  description: "QA Skill: Validate backend state in PostgreSQL using a safe query_id from the local Arcality database validation catalog. Use this after creating/updating records when the mission asks to corroborate persistence in the database. Supports record existence and exact field-value checks. Never accepts raw SQL.",
+  input_schema: {
+    type: "object",
+    properties: {
+      name: {
+        type: "string",
+        description: "Friendly validation name for the report, e.g. 'cliente_creado_en_bd'."
+      },
+      query_id: {
+        type: "string",
+        description: "Query id from .arcality/db-validations.yaml. Raw SQL is not accepted."
+      },
+      params: {
+        type: "object",
+        description: "Named params required by the catalog query, e.g. { name: 'Cliente QA 001' }."
+      },
+      expect: {
+        type: "object",
+        description: "Expected database state. Supports { exists: true/false, fields: { status: 'ACTIVE' } }.",
+        properties: {
+          exists: {
+            type: "boolean",
+            description: "Whether at least one row should exist."
+          },
+          fields: {
+            type: "object",
+            description: "Exact field-value expectations checked against the first returned row."
+          }
+        }
+      },
+      timeout_ms: {
+        type: "number",
+        description: "Optional query timeout in milliseconds."
+      }
+    },
+    required: ["query_id", "params", "expect"]
+  }
+};
+var previewDatabaseValidationTool = {
+  name: "preview_db_validation",
+  description: "QA Skill: Preview an allowlisted PostgreSQL validation query before running a full mission. Use this to verify query_id, params, returned rows, and provider connectivity without requiring an expect block. Never accepts raw SQL.",
+  input_schema: {
+    type: "object",
+    properties: {
+      name: {
+        type: "string",
+        description: "Friendly preview name for the output."
+      },
+      query_id: {
+        type: "string",
+        description: "Query id from .arcality/db-validations.yaml. Raw SQL is not accepted."
+      },
+      params: {
+        type: "object",
+        description: "Named params required by the catalog query."
+      },
+      timeout_ms: {
+        type: "number",
+        description: "Optional query timeout in milliseconds."
+      }
+    },
+    required: ["query_id"]
+  }
+};
+var registerDbProfileTool = {
+  name: "register_db_profile",
+  description: "QA Skill: Register or validate local database profile metadata without exposing secrets. Use this to confirm the provider, profile name, expected env var, catalog path, timeout defaults, and optional MCP config before running database corroboration.",
+  input_schema: {
+    type: "object",
+    properties: {
+      profile: {
+        type: "string",
+        description: "Logical database profile name, e.g. 'qa_local'."
+      },
+      provider: {
+        enum: ["postgres", "mcp"],
+        description: "Database provider mode to validate."
+      },
+      connection_env: {
+        type: "string",
+        description: "Optional explicit env var name that should hold the connection string."
+      },
+      catalog_path: {
+        type: "string",
+        description: "Optional path to the allowlisted query catalog file."
+      },
+      timeout_ms: {
+        type: "number",
+        description: "Optional timeout default for validations."
+      },
+      mcp_config_path: {
+        type: "string",
+        description: "Optional MCP config path when provider is mcp."
+      },
+      validate_catalog: {
+        type: "boolean",
+        description: "Whether to validate that the catalog file can be loaded.",
+        default: true
+      },
+      persist: {
+        type: "boolean",
+        description: "If true, saves non-secret profile metadata into a local registry file.",
+        default: false
+      },
+      registry_path: {
+        type: "string",
+        description: "Optional local registry path used only when persist=true."
+      }
+    }
+  }
+};
+var summarizeExecutionEvidenceTool = {
+  name: "summarize_execution_evidence",
+  description: "QA Skill: Merge UI outcome, database corroboration, console errors, and attachments into one concise evidence summary object. Use this when closing a mission, preparing a report narrative, or resolving contradictions between visible behavior and backend state.",
+  input_schema: {
+    type: "object",
+    properties: {
+      mission_name: {
+        type: "string",
+        description: "Friendly mission name for the summary."
+      },
+      ui_status: {
+        enum: ["passed", "failed", "unknown"],
+        description: "Observed UI outcome status."
+      },
+      ui_summary: {
+        type: "string",
+        description: "Short human summary of what happened in the UI."
+      },
+      expected_business_outcome: {
+        type: "string",
+        description: "Expected business result in plain language."
+      },
+      database_status: {
+        enum: ["passed", "failed", "unknown"],
+        description: "Observed database corroboration status, if already known."
+      },
+      database_validation_name: {
+        type: "string",
+        description: "Optional validation name associated with the DB check."
+      },
+      query_id: {
+        type: "string",
+        description: "Optional query_id associated with the DB check."
+      }
+    }
+  }
+};
 var qaAdvancedTools = [
   validateElementStateTool,
   extractTableDataTool,
@@ -1085,7 +1235,11 @@ var qaAdvancedTools = [
   sendKeyboardEventTool,
   typeSequentiallyTool,
   interactNativeControlTool,
-  scrollPageTool
+  scrollPageTool,
+  validateDatabaseStateTool,
+  previewDatabaseValidationTool,
+  registerDbProfileTool,
+  summarizeExecutionEvidenceTool
 ];
 
 // tests/_helpers/qa-security-tools.ts
@@ -1200,8 +1354,8 @@ async function scan_sensitive_data_exposure(page) {
 }
 
 // tests/_helpers/ai-agent-helper.ts
-var fs5 = __toESM(require("fs"));
-var path5 = __toESM(require("path"));
+var fs6 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
 
 // src/KnowledgeService.ts
 var crypto = __toESM(require("crypto"));
@@ -2088,6 +2242,822 @@ Local context fingerprint: ${localAnalysis.fingerprint || "N/A"}
 `;
 }
 
+// src/services/databaseValidationService.mjs
+var import_fs = __toESM(require("fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
+var import_module = require("module");
+var import_js_yaml = require("js-yaml");
+
+// src/services/mcpStdioClient.mjs
+var import_child_process = require("child_process");
+var import_path = __toESM(require("path"), 1);
+var MCP_PROTOCOL_VERSION = "2024-11-05";
+function isPlainObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function getNestedValue(source, dottedPath) {
+  return String(dottedPath || "").split(".").filter(Boolean).reduce((current, key) => current && Object.prototype.hasOwnProperty.call(current, key) ? current[key] : void 0, source);
+}
+function replaceEnvTokens(value, envSource = process.env) {
+  return String(value).replace(/\$\{([A-Z0-9_]+)\}/gi, (_, envName) => {
+    const resolved = envSource[envName];
+    return resolved === void 0 ? "" : String(resolved);
+  });
+}
+function resolveTemplateValue(value, context = {}, envSource = process.env) {
+  if (typeof value === "string") {
+    const envResolved = replaceEnvTokens(value, envSource);
+    const exactMatch = envResolved.match(/^\{\{\s*([a-zA-Z0-9_.]+)\s*\}\}$/);
+    if (exactMatch) {
+      return getNestedValue(context, exactMatch[1]);
+    }
+    return envResolved.replace(/\{\{\s*([a-zA-Z0-9_.]+)\s*\}\}/g, (_, tokenPath) => {
+      const resolved = getNestedValue(context, tokenPath);
+      if (resolved === void 0 || resolved === null)
+        return "";
+      if (typeof resolved === "string" || typeof resolved === "number" || typeof resolved === "boolean") {
+        return String(resolved);
+      }
+      return JSON.stringify(resolved);
+    });
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => resolveTemplateValue(entry, context, envSource));
+  }
+  if (isPlainObject(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entryValue]) => [key, resolveTemplateValue(entryValue, context, envSource)])
+    );
+  }
+  return value;
+}
+function extractRowsFromMcpToolResult(result, preferredRowsPath = "") {
+  const candidate = preferredRowsPath ? getNestedValue(result, preferredRowsPath) : void 0;
+  if (Array.isArray(candidate))
+    return candidate;
+  if (Array.isArray(result?.rows))
+    return result.rows;
+  const content = Array.isArray(result?.content) ? result.content : [];
+  for (const item of content) {
+    if (!item || item.type !== "text" || typeof item.text !== "string")
+      continue;
+    const text = item.text.trim();
+    if (!text)
+      continue;
+    try {
+      const parsed = JSON.parse(text);
+      if (Array.isArray(parsed))
+        return parsed;
+      if (Array.isArray(parsed?.rows))
+        return parsed.rows;
+      if (preferredRowsPath) {
+        const nested = getNestedValue(parsed, preferredRowsPath);
+        if (Array.isArray(nested))
+          return nested;
+      }
+    } catch {
+    }
+  }
+  return [];
+}
+function createFrame(message) {
+  const body = Buffer.from(JSON.stringify(message), "utf8");
+  const header = Buffer.from(`Content-Length: ${body.length}\r
+\r
+`, "utf8");
+  return Buffer.concat([header, body]);
+}
+function createParser(onMessage) {
+  let buffer = Buffer.alloc(0);
+  return (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+    while (true) {
+      const separatorIndex = buffer.indexOf("\r\n\r\n");
+      if (separatorIndex === -1)
+        return;
+      const headerText = buffer.slice(0, separatorIndex).toString("utf8");
+      const headers = headerText.split("\r\n");
+      const lengthHeader = headers.find((line) => line.toLowerCase().startsWith("content-length:"));
+      if (!lengthHeader) {
+        throw new Error("Invalid MCP response: missing Content-Length header.");
+      }
+      const length = Number(lengthHeader.split(":")[1]?.trim() || 0);
+      const bodyStart = separatorIndex + 4;
+      const bodyEnd = bodyStart + length;
+      if (buffer.length < bodyEnd)
+        return;
+      const body = buffer.slice(bodyStart, bodyEnd).toString("utf8");
+      buffer = buffer.slice(bodyEnd);
+      onMessage(JSON.parse(body));
+    }
+  };
+}
+async function callMcpToolWithConfig(config, toolContext = {}) {
+  if (!config || !config.command) {
+    throw new Error("MCP configuration is missing the command field.");
+  }
+  const timeoutMs = Number(config.timeoutMs || toolContext.timeoutMs || 15e3);
+  const command = resolveTemplateValue(config.command, toolContext);
+  const args = Array.isArray(config.args) ? resolveTemplateValue(config.args, toolContext) : [];
+  const envFromConfig = isPlainObject(config.env) ? resolveTemplateValue(config.env, toolContext) : {};
+  const cwd = config.cwd ? resolveTemplateValue(config.cwd, toolContext) : process.cwd();
+  const toolName = String(resolveTemplateValue(config.toolName || "query", toolContext) || "").trim();
+  const toolArguments = isPlainObject(config.toolArguments) ? resolveTemplateValue(config.toolArguments, toolContext) : {};
+  const child = (0, import_child_process.spawn)(command, args, {
+    cwd: import_path.default.isAbsolute(cwd) ? cwd : import_path.default.join(process.cwd(), cwd),
+    env: { ...process.env, ...envFromConfig },
+    stdio: ["pipe", "pipe", "pipe"],
+    windowsHide: true
+  });
+  let requestId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  let startupError = "";
+  const parser = createParser((message) => {
+    if (message.id && pending.has(message.id)) {
+      const entry = pending.get(message.id);
+      pending.delete(message.id);
+      if (message.error) {
+        entry.reject(new Error(message.error.message || "Unknown MCP error."));
+      } else {
+        entry.resolve(message.result);
+      }
+    }
+  });
+  child.stdout.on("data", (chunk) => parser(chunk));
+  child.stderr.on("data", (chunk) => {
+    startupError += chunk.toString("utf8");
+  });
+  child.on("error", (error) => {
+    for (const [, entry] of pending)
+      entry.reject(error);
+    pending.clear();
+  });
+  const sendRequest = (method, params) => new Promise((resolve2, reject) => {
+    const id = requestId++;
+    pending.set(id, { resolve: resolve2, reject });
+    child.stdin.write(createFrame({ jsonrpc: "2.0", id, method, params }));
+  });
+  const sendNotification = (method, params) => {
+    child.stdin.write(createFrame({ jsonrpc: "2.0", method, params }));
+  };
+  const timeout = new Promise((_, reject) => {
+    setTimeout(() => reject(new Error(`MCP tool call timed out after ${timeoutMs}ms.`)), timeoutMs);
+  });
+  try {
+    const result = await Promise.race([
+      (async () => {
+        await sendRequest("initialize", {
+          protocolVersion: MCP_PROTOCOL_VERSION,
+          capabilities: {},
+          clientInfo: { name: "arcality", version: "4.1.0" }
+        });
+        sendNotification("notifications/initialized", {});
+        return await sendRequest("tools/call", {
+          name: toolName,
+          arguments: toolArguments
+        });
+      })(),
+      timeout
+    ]);
+    return result;
+  } catch (error) {
+    const details = startupError.trim();
+    if (details) {
+      throw new Error(`${error.message} MCP stderr: ${details}`);
+    }
+    throw error;
+  } finally {
+    child.kill();
+  }
+}
+
+// src/services/databaseValidationService.mjs
+var DEFAULT_TIMEOUT_MS = 8e3;
+var DEFAULT_SAMPLE_LIMIT = 3;
+var DEFAULT_CATALOG_PATH = import_path2.default.join(".arcality", "db-validations.yaml");
+var DEFAULT_MCP_CONFIG_PATH = import_path2.default.join(".arcality", "mcp.postgres.json");
+var SENSITIVE_FIELD_PATTERN = /(password|passwd|pwd|secret|token|api[_-]?key|authorization|auth|credential|session|cookie)/i;
+var SQL_WRITE_PATTERN = /\b(insert|update|delete|drop|alter|create|truncate|grant|revoke|vacuum|copy|call|execute|merge)\b/i;
+function toEnvKey(value) {
+  return String(value || "").trim().toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+function isEnabled(value) {
+  return ["1", "true", "yes", "on"].includes(String(value || "").trim().toLowerCase());
+}
+function isPlainObject2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeDbValue(value) {
+  if (value instanceof Date)
+    return value.toISOString();
+  if (typeof value === "bigint")
+    return value.toString();
+  if (Buffer.isBuffer(value))
+    return "[binary]";
+  if (Array.isArray(value))
+    return value.map(normalizeDbValue);
+  if (isPlainObject2(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entryValue]) => [key, normalizeDbValue(entryValue)])
+    );
+  }
+  return value;
+}
+function normalizeRows(rows) {
+  if (!Array.isArray(rows))
+    return [];
+  return rows.map((row) => normalizeDbValue(row));
+}
+function normalizeRedactSet(...sources) {
+  const redact = /* @__PURE__ */ new Set();
+  for (const source of sources) {
+    if (Array.isArray(source)) {
+      for (const field of source) {
+        const name = String(field || "").trim();
+        if (name)
+          redact.add(name);
+      }
+    }
+  }
+  return redact;
+}
+function shouldRedactField(field, redactSet) {
+  return redactSet.has(field) || SENSITIVE_FIELD_PATTERN.test(field);
+}
+function redactValue(value) {
+  if (value === void 0 || value === null)
+    return value;
+  return "[REDACTED]";
+}
+function redactObject(value, redactSet) {
+  if (!isPlainObject2(value))
+    return value;
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entryValue]) => [
+      key,
+      shouldRedactField(key, redactSet) ? redactValue(entryValue) : entryValue
+    ])
+  );
+}
+function redactRows(rows, redactSet, limit = DEFAULT_SAMPLE_LIMIT) {
+  return normalizeRows(rows).slice(0, limit).map((row) => redactObject(row, redactSet));
+}
+function validateReadOnlySql(sql) {
+  const text = String(sql || "").trim();
+  if (!text) {
+    throw new Error("Database validation query is empty.");
+  }
+  const withoutTrailingSemicolon = text.replace(/;\s*$/, "");
+  if (withoutTrailingSemicolon.includes(";")) {
+    throw new Error("Database validation queries must contain a single statement.");
+  }
+  if (!/^(select|with)\b/i.test(withoutTrailingSemicolon)) {
+    throw new Error("Database validation queries must start with SELECT or WITH.");
+  }
+  if (SQL_WRITE_PATTERN.test(withoutTrailingSemicolon)) {
+    throw new Error("Database validation queries must be read-only.");
+  }
+}
+function resolveConfigPath(configPath, fallbackPath, options = {}) {
+  const projectRoot = options.projectRoot || process.env.ARCALITY_PROJECT_ROOT || process.cwd();
+  return import_path2.default.isAbsolute(configPath) ? configPath : import_path2.default.join(projectRoot, configPath || fallbackPath);
+}
+function readJsonOrYamlFile(filePath) {
+  const raw = import_fs.default.readFileSync(filePath, "utf8");
+  if (/\.json$/i.test(filePath)) {
+    return JSON.parse(raw);
+  }
+  return (0, import_js_yaml.load)(raw);
+}
+function resolveCatalogPath(options = {}) {
+  const configuredPath = options.catalogPath || process.env.ARCALITY_DB_CATALOG || process.env.ARCALITY_DB_VALIDATIONS_FILE || DEFAULT_CATALOG_PATH;
+  return resolveConfigPath(configuredPath, DEFAULT_CATALOG_PATH, options);
+}
+function resolveMcpConfigPath(options = {}) {
+  const configuredPath = options.mcpConfigPath || process.env.ARCALITY_DB_MCP_CONFIG || DEFAULT_MCP_CONFIG_PATH;
+  return resolveConfigPath(configuredPath, DEFAULT_MCP_CONFIG_PATH, options);
+}
+function loadDatabaseValidationCatalog(options = {}) {
+  const catalogPath = resolveCatalogPath(options);
+  if (!import_fs.default.existsSync(catalogPath)) {
+    throw new Error(`Database validation catalog not found: ${catalogPath}`);
+  }
+  const raw = readJsonOrYamlFile(catalogPath);
+  const catalog = raw && typeof raw === "object" ? raw : {};
+  const queries = isPlainObject2(catalog.queries) ? catalog.queries : {};
+  return { catalogPath, queries };
+}
+function loadDatabaseMcpConfig(options = {}) {
+  const configPath = resolveMcpConfigPath(options);
+  if (!import_fs.default.existsSync(configPath)) {
+    throw new Error(`MCP database config not found: ${configPath}`);
+  }
+  const raw = readJsonOrYamlFile(configPath);
+  if (!isPlainObject2(raw)) {
+    throw new Error(`Invalid MCP database config: ${configPath}`);
+  }
+  return { configPath, config: raw };
+}
+function resolveDatabaseProvider(options = {}) {
+  const rawProvider = String(options.provider || process.env.ARCALITY_DB_PROVIDER || "postgres").trim().toLowerCase();
+  if (["mcp", "mcp_postgres", "mcp-postgres"].includes(rawProvider)) {
+    return "mcp";
+  }
+  return "postgres";
+}
+function resolveDatabaseConnectionEnv(options = {}) {
+  const profile = String(options.profile || process.env.ARCALITY_DB_PROFILE || "qa_local").trim();
+  const profileKey = toEnvKey(profile);
+  const profileEnvName = profileKey ? `ARCALITY_DB_${profileKey}_URL` : "";
+  const connectionEnvName = options.connectionEnv || process.env.ARCALITY_DB_CONNECTION_ENV || profileEnvName || "ARCALITY_DB_CONNECTION";
+  const connectionString = process.env[connectionEnvName] || process.env.ARCALITY_DB_CONNECTION || process.env.ARCALITY_QA_POSTGRES_URL || "";
+  return {
+    profile,
+    connectionEnvName,
+    hasConnectionString: !!connectionString,
+    connectionString
+  };
+}
+function normalizeTimeoutMs(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_TIMEOUT_MS;
+}
+function resolveProfileRegistryPath(options = {}) {
+  const configuredPath = options.registryPath || options.registry_path || import_path2.default.join(".arcality", "db-profiles.json");
+  return resolveConfigPath(configuredPath, import_path2.default.join(".arcality", "db-profiles.json"), options);
+}
+function registerDatabaseProfile(profileInput = {}, options = {}) {
+  const profile = String(profileInput.profile || options.profile || process.env.ARCALITY_DB_PROFILE || "qa_local").trim() || "qa_local";
+  const provider = resolveDatabaseProvider({ provider: profileInput.provider || options.provider || process.env.ARCALITY_DB_PROVIDER });
+  const connection = resolveDatabaseConnectionEnv({
+    profile,
+    connectionEnv: profileInput.connection_env || profileInput.connectionEnv || options.connectionEnv
+  });
+  const catalogPath = resolveCatalogPath({
+    ...options,
+    catalogPath: profileInput.catalog_path || profileInput.catalogPath
+  });
+  const timeoutMs = normalizeTimeoutMs(profileInput.timeout_ms || profileInput.timeoutMs || options.timeoutMs || process.env.ARCALITY_DB_TIMEOUT_MS);
+  const warnings = [];
+  const result = {
+    type: "database_profile_registration",
+    profile,
+    provider,
+    connection_env: connection.connectionEnvName,
+    has_connection_string: connection.hasConnectionString,
+    catalog_path: catalogPath,
+    catalog_exists: import_fs.default.existsSync(catalogPath),
+    timeout_ms: timeoutMs,
+    warnings
+  };
+  if (!result.has_connection_string) {
+    warnings.push("Missing PostgreSQL connection string in " + connection.connectionEnvName + ".");
+  }
+  if (!result.catalog_exists) {
+    warnings.push("Database validation catalog not found: " + catalogPath);
+  }
+  if (profileInput.validate_catalog !== false && result.catalog_exists) {
+    try {
+      const catalog = loadDatabaseValidationCatalog({ ...options, catalogPath });
+      result.query_count = Object.keys(catalog.queries || {}).length;
+    } catch (error) {
+      result.query_count = 0;
+      warnings.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+  if (provider === "mcp") {
+    const mcpConfigPath = resolveMcpConfigPath({
+      ...options,
+      mcpConfigPath: profileInput.mcp_config_path || profileInput.mcpConfigPath
+    });
+    result.mcp_config_path = mcpConfigPath;
+    result.mcp_config_exists = import_fs.default.existsSync(mcpConfigPath);
+    if (!result.mcp_config_exists) {
+      warnings.push("MCP database config not found: " + mcpConfigPath);
+    }
+  }
+  if (profileInput.persist === true) {
+    const registryPath = resolveProfileRegistryPath({
+      ...options,
+      registryPath: profileInput.registry_path || profileInput.registryPath
+    });
+    let registry = { profiles: {} };
+    if (import_fs.default.existsSync(registryPath)) {
+      try {
+        const existing = JSON.parse(import_fs.default.readFileSync(registryPath, "utf8"));
+        if (existing && typeof existing === "object" && !Array.isArray(existing)) {
+          registry = existing;
+          registry.profiles = registry.profiles && typeof registry.profiles === "object" ? registry.profiles : {};
+        }
+      } catch {
+      }
+    }
+    registry.profiles[profile] = {
+      provider,
+      connection_env: connection.connectionEnvName,
+      catalog_path: catalogPath,
+      timeout_ms: timeoutMs,
+      ...result.mcp_config_path ? { mcp_config_path: result.mcp_config_path } : {}
+    };
+    import_fs.default.mkdirSync(import_path2.default.dirname(registryPath), { recursive: true });
+    import_fs.default.writeFileSync(registryPath, JSON.stringify(registry, null, 2), "utf8");
+    result.persisted = true;
+    result.registry_path = registryPath;
+  } else {
+    result.persisted = false;
+  }
+  result.status = warnings.length === 0 ? "ready" : "warning";
+  return result;
+}
+function loadPgPool() {
+  const roots = [process.env.ARCALITY_ROOT, process.cwd()].filter(Boolean);
+  for (const root of roots) {
+    try {
+      const requireFromRoot = (0, import_module.createRequire)(import_path2.default.join(root, "package.json"));
+      const pg = requireFromRoot("pg");
+      return pg.Pool;
+    } catch {
+    }
+  }
+  throw new Error('PostgreSQL driver "pg" is not installed. Run `npm install pg --save` in this project to enable database validation.');
+}
+function getQueryEntry(catalog, queryId) {
+  const entry = catalog.queries[queryId];
+  if (!isPlainObject2(entry)) {
+    throw new Error(`Database validation query_id not found in catalog: ${queryId}`);
+  }
+  validateReadOnlySql(entry.sql);
+  return entry;
+}
+function buildQueryValues(entry, params) {
+  const paramNames = Array.isArray(entry.params) ? entry.params : [];
+  return paramNames.map((name) => {
+    const key = String(name);
+    if (!Object.prototype.hasOwnProperty.call(params || {}, key)) {
+      throw new Error(`Missing database validation param: ${key}`);
+    }
+    return params[key];
+  });
+}
+function evaluateDatabaseValidationRows(validation, rows, queryEntry = {}) {
+  if (!isPlainObject2(validation)) {
+    throw new Error("Database validation must be an object.");
+  }
+  const normalizedRows = normalizeRows(rows);
+  const expectBlock = isPlainObject2(validation.expect) ? validation.expect : {};
+  const expectsFields = isPlainObject2(expectBlock.fields);
+  const expectedExists = typeof expectBlock.exists === "boolean" ? expectBlock.exists : expectsFields ? true : void 0;
+  const redactSet = normalizeRedactSet(queryEntry.redact, validation.redact);
+  const checks = [];
+  if (typeof expectedExists === "boolean") {
+    const actualExists = normalizedRows.length > 0;
+    checks.push({
+      type: "exists",
+      expected: expectedExists,
+      actual: actualExists,
+      passed: actualExists === expectedExists
+    });
+  }
+  if (expectsFields) {
+    const firstRow = normalizedRows[0] || {};
+    for (const [field, expected] of Object.entries(expectBlock.fields)) {
+      const hasField = Object.prototype.hasOwnProperty.call(firstRow, field);
+      const actual = hasField ? firstRow[field] : void 0;
+      const passed2 = hasField && actual === normalizeDbValue(expected);
+      const redacted = shouldRedactField(field, redactSet);
+      checks.push({
+        type: "field_exact",
+        field,
+        expected: redacted ? redactValue(expected) : normalizeDbValue(expected),
+        actual: redacted ? redactValue(actual) : actual,
+        passed: passed2
+      });
+    }
+  }
+  const passed = checks.length > 0 && checks.every((check) => check.passed);
+  return {
+    name: String(validation.name || validation.query_id || validation.queryId || "database_validation"),
+    query_id: String(validation.query_id || validation.queryId || ""),
+    status: passed ? "passed" : "failed",
+    passed,
+    row_count: normalizedRows.length,
+    checks,
+    rows_sample: redactRows(normalizedRows, redactSet)
+  };
+}
+async function queryWithTimeout(pool, query, timeoutMs) {
+  let timeoutHandle;
+  const timeout = new Promise((_, reject) => {
+    timeoutHandle = setTimeout(() => {
+      reject(new Error(`Database validation query timed out after ${timeoutMs}ms.`));
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([pool.query(query), timeout]);
+  } finally {
+    clearTimeout(timeoutHandle);
+  }
+}
+async function queryDatabaseRowsViaPostgres({ validation, queryEntry, timeoutMs, startedAt, options = {} }) {
+  const connection = resolveDatabaseConnectionEnv({ profile: validation.profile || options.profile });
+  if (!connection.hasConnectionString) {
+    throw new Error(`Missing PostgreSQL connection string in ${connection.connectionEnvName}.`);
+  }
+  const Pool = loadPgPool();
+  const values = buildQueryValues(queryEntry, validation.params || {});
+  const pool = new Pool({
+    connectionString: connection.connectionString,
+    max: 1,
+    idleTimeoutMillis: 1e3,
+    connectionTimeoutMillis: Math.min(timeoutMs, 1e4),
+    statement_timeout: timeoutMs
+  });
+  try {
+    const result = await queryWithTimeout(pool, { text: queryEntry.sql, values }, timeoutMs);
+    return {
+      rows: result.rows || [],
+      metadata: {
+        provider: "postgres",
+        profile: connection.profile,
+        catalog_path: options.catalogPath || resolveCatalogPath(options),
+        duration_ms: Date.now() - startedAt,
+        executed_at: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+  } finally {
+    await pool.end().catch(() => {
+    });
+  }
+}
+async function executeDatabaseValidationViaPostgres({ validation, queryEntry, timeoutMs, startedAt, options = {} }) {
+  const { rows, metadata } = await queryDatabaseRowsViaPostgres({ validation, queryEntry, timeoutMs, startedAt, options });
+  const evaluated = evaluateDatabaseValidationRows(validation, rows, queryEntry);
+  return {
+    ...evaluated,
+    ...metadata
+  };
+}
+async function queryDatabaseRowsViaMcp({ validation, queryEntry, timeoutMs, startedAt, options = {} }) {
+  const { configPath, config } = loadDatabaseMcpConfig(options);
+  const values = buildQueryValues(queryEntry, validation.params || {});
+  const toolContext = {
+    sql: queryEntry.sql,
+    params: values,
+    paramsNamed: validation.params || {},
+    paramsJson: JSON.stringify(values),
+    queryId: validation.query_id || validation.queryId || "",
+    validationName: validation.name || validation.query_id || validation.queryId || "database_validation",
+    timeoutMs
+  };
+  const result = await callMcpToolWithConfig(config, toolContext);
+  const rows = extractRowsFromMcpToolResult(result, String(config.resultRowsPath || "").trim());
+  return {
+    rows,
+    metadata: {
+      provider: "mcp",
+      mcp_config_path: configPath,
+      mcp_tool_name: String(config.toolName || "query"),
+      catalog_path: options.catalogPath || resolveCatalogPath(options),
+      duration_ms: Date.now() - startedAt,
+      executed_at: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+async function executeDatabaseValidationViaMcp({ validation, queryEntry, timeoutMs, startedAt, options = {} }) {
+  const { rows, metadata } = await queryDatabaseRowsViaMcp({ validation, queryEntry, timeoutMs, startedAt, options });
+  const evaluated = evaluateDatabaseValidationRows(validation, rows, queryEntry);
+  return {
+    ...evaluated,
+    ...metadata
+  };
+}
+async function executeDatabaseValidation(validation, options = {}) {
+  if (!isEnabled(process.env.ARCALITY_DB_ENABLED) && !options.allowDisabled) {
+    throw new Error("Database validation is disabled. Set ARCALITY_DB_ENABLED=true to use it.");
+  }
+  const queryId = String(validation?.query_id || validation?.queryId || "").trim();
+  if (!queryId) {
+    throw new Error("Database validation requires query_id.");
+  }
+  const startedAt = Date.now();
+  const catalog = loadDatabaseValidationCatalog(options);
+  const queryEntry = getQueryEntry(catalog, queryId);
+  const timeoutMs = Number(validation.timeout_ms || validation.timeoutMs || process.env.ARCALITY_DB_TIMEOUT_MS || DEFAULT_TIMEOUT_MS);
+  const provider = resolveDatabaseProvider(options);
+  if (provider === "mcp") {
+    return executeDatabaseValidationViaMcp({ validation, queryEntry, timeoutMs, startedAt, options: { ...options, catalogPath: catalog.catalogPath } });
+  }
+  return executeDatabaseValidationViaPostgres({ validation, queryEntry, timeoutMs, startedAt, options: { ...options, catalogPath: catalog.catalogPath } });
+}
+function buildDatabaseValidationPreview(validation, rows, queryEntry = {}, metadata = {}) {
+  const redactSet = normalizeRedactSet(queryEntry.redact, validation?.redact);
+  const normalizedRows = normalizeRows(rows);
+  return {
+    type: "database_validation_preview",
+    name: String(validation?.name || validation?.query_id || validation?.queryId || "database_validation_preview"),
+    query_id: String(validation?.query_id || validation?.queryId || ""),
+    params: redactObject(normalizeDbValue(validation?.params || {}), redactSet),
+    row_count: normalizedRows.length,
+    rows_sample: redactRows(normalizedRows, redactSet),
+    query: {
+      description: String(queryEntry.description || ""),
+      params: Array.isArray(queryEntry.params) ? queryEntry.params.map((name) => String(name)) : []
+    },
+    supports_expect: {
+      exists: true,
+      fields: true
+    },
+    ...metadata
+  };
+}
+async function previewDatabaseValidation(validation, options = {}) {
+  if (!isEnabled(process.env.ARCALITY_DB_ENABLED) && !options.allowDisabled) {
+    throw new Error("Database validation is disabled. Set ARCALITY_DB_ENABLED=true to use it.");
+  }
+  const queryId = String(validation?.query_id || validation?.queryId || "").trim();
+  if (!queryId) {
+    throw new Error("Database validation preview requires query_id.");
+  }
+  const startedAt = Date.now();
+  const catalog = loadDatabaseValidationCatalog(options);
+  const queryEntry = getQueryEntry(catalog, queryId);
+  const timeoutMs = Number(validation?.timeout_ms || validation?.timeoutMs || process.env.ARCALITY_DB_TIMEOUT_MS || DEFAULT_TIMEOUT_MS);
+  const provider = resolveDatabaseProvider(options);
+  const normalizedValidation = {
+    ...validation,
+    query_id: queryId,
+    name: String(validation?.name || queryId || "database_validation_preview"),
+    params: isPlainObject2(validation?.params) ? validation.params : {}
+  };
+  const execution = provider === "mcp" ? await queryDatabaseRowsViaMcp({ validation: normalizedValidation, queryEntry, timeoutMs, startedAt, options: { ...options, catalogPath: catalog.catalogPath } }) : await queryDatabaseRowsViaPostgres({ validation: normalizedValidation, queryEntry, timeoutMs, startedAt, options: { ...options, catalogPath: catalog.catalogPath } });
+  return buildDatabaseValidationPreview(normalizedValidation, execution.rows, queryEntry, execution.metadata);
+}
+async function runDatabaseValidations(validations, options = {}) {
+  const list = Array.isArray(validations) ? validations : [];
+  const startedAt = Date.now();
+  const results = [];
+  for (const validation of list) {
+    try {
+      results.push(await executeDatabaseValidation(validation, options));
+    } catch (error) {
+      results.push({
+        name: String(validation?.name || validation?.query_id || validation?.queryId || "database_validation"),
+        query_id: String(validation?.query_id || validation?.queryId || ""),
+        status: "failed",
+        passed: false,
+        row_count: 0,
+        checks: [],
+        rows_sample: [],
+        error: error instanceof Error ? error.message : String(error),
+        executed_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
+  const passedCount = results.filter((result) => result.passed).length;
+  return {
+    type: "database_validation_report",
+    status: passedCount === results.length ? "passed" : "failed",
+    passed: results.length > 0 && passedCount === results.length,
+    summary: {
+      total: results.length,
+      passed: passedCount,
+      failed: results.length - passedCount
+    },
+    duration_ms: Date.now() - startedAt,
+    executed_at: (/* @__PURE__ */ new Date()).toISOString(),
+    validations: results
+  };
+}
+function parseDatabaseValidationsFromEnv(env = process.env) {
+  const raw = env.ARCALITY_DB_VALIDATIONS_JSON || env.ARCALITY_DB_VALIDATIONS || "";
+  if (!raw.trim())
+    return [];
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+async function runDatabaseValidationsFromEnv(options = {}) {
+  const validations = parseDatabaseValidationsFromEnv();
+  if (validations.length === 0)
+    return null;
+  return runDatabaseValidations(validations, options);
+}
+
+// src/services/executionEvidenceService.mjs
+function normalizeStatus(value) {
+  const normalized = String(value || "").trim().toLowerCase();
+  if (normalized === "passed" || normalized === "pass" || normalized === "success")
+    return "passed";
+  if (normalized === "failed" || normalized === "fail" || normalized === "error")
+    return "failed";
+  return "unknown";
+}
+function classifyLogs(logs = []) {
+  const entries = Array.isArray(logs) ? logs.map((entry) => String(entry || "").trim()).filter(Boolean) : [];
+  const errors = entries.filter((entry) => entry.includes("[ERROR]") || entry.includes("[NETWORK_ERROR]"));
+  const warnings = entries.filter((entry) => entry.includes("[WARNING]"));
+  return {
+    total: entries.length,
+    error_count: errors.length,
+    warning_count: warnings.length,
+    recent: entries.slice(-10)
+  };
+}
+function summarizeAttachments(attachments = []) {
+  const normalized = Array.isArray(attachments) ? attachments.map((att) => ({
+    name: String(att?.name || "").trim(),
+    contentType: String(att?.contentType || "").trim(),
+    path: att?.path ? String(att.path) : void 0
+  })).filter((att) => att.name || att.contentType || att.path) : [];
+  return {
+    total: normalized.length,
+    images: normalized.filter((att) => att.contentType.startsWith("image/")).length,
+    videos: normalized.filter((att) => att.contentType.startsWith("video/")).length,
+    json: normalized.filter((att) => att.contentType === "application/json").length,
+    names: normalized.map((att) => att.name || att.path || "attachment").slice(0, 12)
+  };
+}
+function deriveDatabaseStatus(input) {
+  const explicit = normalizeStatus(input?.database_status);
+  if (explicit !== "unknown")
+    return explicit;
+  if (typeof input?.database_report?.passed === "boolean") {
+    return input.database_report.passed ? "passed" : "failed";
+  }
+  return "unknown";
+}
+function buildContradictions(uiStatus, dbStatus) {
+  const contradictions = [];
+  if (uiStatus === "passed" && dbStatus === "failed")
+    contradictions.push("ui_passed_but_db_failed");
+  if (uiStatus === "failed" && dbStatus === "passed")
+    contradictions.push("ui_failed_but_db_passed");
+  return contradictions;
+}
+function buildRemediationHints(finalStatus, contradictions, consoleSummary) {
+  const hints = [];
+  if (contradictions.includes("ui_passed_but_db_failed")) {
+    hints.push("Revisar la persistencia backend o la confirmacion visual de guardado.");
+  }
+  if (contradictions.includes("ui_failed_but_db_passed")) {
+    hints.push("Revisar si la UI muestra un error falso o si el flujo se completo parcialmente.");
+  }
+  if (consoleSummary.error_count > 0) {
+    hints.push("Inspeccionar errores de consola o red asociados al momento de la falla.");
+  }
+  if (finalStatus === "unknown") {
+    hints.push("Completar evidencia faltante antes de cerrar la conclusion.");
+  }
+  return hints;
+}
+function summarizeExecutionEvidence(input = {}, context = {}) {
+  const uiStatus = normalizeStatus(input.ui_status);
+  const dbStatus = deriveDatabaseStatus(input);
+  const consoleSummary = classifyLogs(context.logs || input.console_logs);
+  const attachmentSummary = summarizeAttachments(context.attachments || input.attachments);
+  const contradictions = buildContradictions(uiStatus, dbStatus);
+  let finalStatus = "unknown";
+  if (contradictions.length > 0) {
+    finalStatus = "contradiction";
+  } else if (uiStatus === "failed" || dbStatus === "failed") {
+    finalStatus = "failed";
+  } else if (uiStatus === "passed" || dbStatus === "passed") {
+    finalStatus = "passed";
+  }
+  const remediationHints = buildRemediationHints(finalStatus, contradictions, consoleSummary);
+  const missionName = String(input.mission_name || input.name || "execution_evidence").trim();
+  const expectedOutcome = String(input.expected_business_outcome || "").trim();
+  const uiSummary = String(input.ui_summary || "").trim();
+  const validationName = String(input.database_validation_name || input.database_report?.name || "").trim();
+  const queryId = String(input.query_id || input.database_report?.query_id || "").trim();
+  const summary = finalStatus === "contradiction" ? "La evidencia es contradictoria entre UI y base de datos." : finalStatus === "failed" ? "La ejecucion contiene evidencia suficiente para marcar falla." : finalStatus === "passed" ? "La evidencia disponible respalda un resultado exitoso." : "La ejecucion requiere mas evidencia para una conclusion firme.";
+  return {
+    type: "execution_evidence_summary",
+    mission_name: missionName,
+    final_status: finalStatus,
+    summary,
+    expected_business_outcome: expectedOutcome || void 0,
+    current_url: context.current_url || input.current_url || void 0,
+    ui: {
+      status: uiStatus,
+      summary: uiSummary || void 0
+    },
+    database: {
+      status: dbStatus,
+      validation_name: validationName || void 0,
+      query_id: queryId || void 0
+    },
+    console: consoleSummary,
+    attachments: attachmentSummary,
+    contradictions,
+    remediation_hints: remediationHints,
+    generated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
 // tests/_helpers/ai-agent-helper.ts
 var qaSecurityTools = [
   {
@@ -2190,11 +3160,11 @@ var AIAgentHelper = class {
       }
     });
     this.page.on("pageerror", (exception) => {
-      this.criticalJsError = `Excepci\xF3n JS no manejada: ${exception.message}`;
+      this.criticalJsError = `Excepci\uFFFDn JS no manejada: ${exception.message}`;
       this.logs.push(`[JS_CRASH] ${exception.message}`);
     });
     this.page.on("crash", () => {
-      this.criticalJsError = `Browser Crash: La pesta\xF1a del navegador colaps\xF3 inesperadamente.`;
+      this.criticalJsError = `Browser Crash: La pesta\uFFFDa del navegador colaps\uFFFD inesperadamente.`;
     });
   }
   clearNetworkError() {
@@ -2204,54 +3174,51 @@ var AIAgentHelper = class {
     try {
       let skillsContext = "";
       let loadedCount = 0;
-      const toolsRoot = process.env.ARCALITY_ROOT || path5.join(__dirname, "..", "..");
-      const possibleDirs = [
-        path5.join(toolsRoot, ".agent", "skills"),
-        path5.join(toolsRoot, ".agents", "skills")
-      ];
-      for (const rootDir of possibleDirs) {
-        if (!fs5.existsSync(rootDir))
-          continue;
-        if (loadedCount === 0) {
-          skillsContext += "\n\u{1F6E0}\uFE0F SKILLS INSTALADAS (Metodolog\xEDas activas):\n";
-        }
-        const entries = fs5.readdirSync(rootDir, { withFileTypes: true });
-        for (const entry of entries) {
-          let content = "";
-          let skillName = entry.name;
-          if (entry.isDirectory()) {
-            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 = path5.join(rootDir, entry.name);
-            content = fs5.readFileSync(skillPath, "utf8");
+      const toolsRoot = process.env.ARCALITY_ROOT || path7.join(__dirname, "..", "..");
+      const rootDir = path7.join(toolsRoot, ".agents", "skills");
+      if (!fs6.existsSync(rootDir)) {
+        return "";
+      }
+      if (loadedCount === 0) {
+        skillsContext += "\nSKILLS INSTALADAS (Metodologias activas):\n";
+      }
+      const entries = fs6.readdirSync(rootDir, { withFileTypes: true });
+      for (const entry of entries) {
+        let content = "";
+        let skillName = entry.name;
+        if (entry.isDirectory()) {
+          const skillPath = path7.join(rootDir, entry.name, "SKILL.md");
+          if (fs6.existsSync(skillPath)) {
+            content = fs6.readFileSync(skillPath, "utf8");
           }
-          if (content) {
-            skillsContext += `
+        } else if (entry.name === "SKILL.md") {
+          const skillPath = path7.join(rootDir, entry.name);
+          skillName = path7.basename(rootDir);
+          content = fs6.readFileSync(skillPath, "utf8");
+        }
+        if (content) {
+          skillsContext += `
 --- SKILL: ${skillName} ---
 ${content}
 `;
-            loadedCount++;
-          }
+          loadedCount++;
         }
       }
       if (loadedCount > 0) {
         if (process.env.DEBUG)
-          console.log(`>> \u{1F4D1} ${loadedCount} habilidades QA inyectadas al cerebro.`);
+          console.log(`>> [skills] ${loadedCount} habilidades QA inyectadas al cerebro.`);
         return skillsContext;
       }
     } catch (e) {
-      console.warn(`>>ARCALITY_STATUS>> \u26A0\uFE0F Error cargando habilidades: ${e.message}`);
+      console.warn(`>>ARCALITY_STATUS>> Error cargando habilidades: ${e.message}`);
     }
     return "";
   }
   loadMemory(prompt) {
     try {
-      const memoryFile = path5.join(this.contextDir, "memoria-agente.json");
-      if (fs5.existsSync(memoryFile)) {
-        const memories = JSON.parse(fs5.readFileSync(memoryFile, "utf8"));
+      const memoryFile = path7.join(this.contextDir, "memoria-agente.json");
+      if (fs6.existsSync(memoryFile)) {
+        const memories = JSON.parse(fs6.readFileSync(memoryFile, "utf8"));
         const keywords = prompt.toLowerCase().split(" ").filter((w) => w.length > 4);
         const relevantSuccess = memories.filter((m) => {
           if (!m.success)
@@ -2265,7 +3232,7 @@ ${content}
         if (relevantSuccess.length) {
           const best = relevantSuccess[0];
           memoryContext += `
-\u{1F4DA} SUCCESS GUIDANCE FOR THIS MISSION:
+?? SUCCESS GUIDANCE FOR THIS MISSION:
 The following steps led to SUCCESS for a similar mission ("${best.prompt}"):
 ${best.steps.slice(0, 15).map((s) => `  - ${s}`).join("\n")}
 (Use these steps as a roadmap if the current UI allows it!)
@@ -2273,7 +3240,7 @@ ${best.steps.slice(0, 15).map((s) => `  - ${s}`).join("\n")}
         }
         if (relevantFailures.length) {
           memoryContext += `
-\u26A0\uFE0F PREVIOUS FAILURES TO AVOID:
+?? PREVIOUS FAILURES TO AVOID:
 ${relevantFailures.map((m) => `- ${m.prompt}`).join("\n")}
 `;
         }
@@ -2325,11 +3292,11 @@ ${relevantFailures.map((m) => `- ${m.prompt}`).join("\n")}
             const role = htmlEl.getAttribute("role") || "";
             const text = (htmlEl.innerText || htmlEl.getAttribute("aria-label") || htmlEl.getAttribute("title") || "").trim().replace(/\s+/g, " ");
             const textLower = text.toLowerCase();
-            const isCriticalFailure = (textLower.includes("error") || textLower.includes("fall\xF3") || textLower.includes("no se puede") || textLower.includes("ya existe") || textLower.includes("inv\xE1lido") || textLower.includes("incorrecto") || textLower.includes("ligado") || textLower.includes("depende") || textLower.includes("duplicado") || textLower.includes("repetido") || /* Validaciones ZOD / Wizard de campos de formulario */
+            const isCriticalFailure = (textLower.includes("error") || textLower.includes("fall\uFFFD") || textLower.includes("no se puede") || textLower.includes("ya existe") || textLower.includes("inv\uFFFDlido") || textLower.includes("incorrecto") || textLower.includes("ligado") || textLower.includes("depende") || textLower.includes("duplicado") || textLower.includes("repetido") || /* Validaciones ZOD / Wizard de campos de formulario */
             textLower.includes("debe ser mayor") || textLower.includes("debe ser menor") || textLower.includes("debe ser igual") || textLower.includes("debe ser mayor o igual") || textLower.includes("debe ser menor o igual") || /* ZOD date messages (Spanish) */
-            textLower.includes("debe ser posterior") || textLower.includes("debe ser anterior") || textLower.includes("debe ser una fecha") || textLower.includes("fecha debe ser") || textLower.includes("posterior o igual a la fecha") || textLower.includes("anterior o igual a la fecha") || textLower.includes("posterior a la fecha") || textLower.includes("anterior a la fecha") || textLower.includes("fecha") && (textLower.includes("actual") || textLower.includes("pasada") || textLower.includes("futura") || textLower.includes("requerida") || textLower.includes("inv\xE1lida") || textLower.includes("incorrecta") || textLower.includes("posterior") || textLower.includes("anterior")) || /* ZOD number/range messages */
-            textLower.includes("debe ser un n\xFAmero") || textLower.includes("debe ser positivo") || textLower.includes("debe ser negativo") || textLower.includes("m\xEDnimo") && textLower.includes("caracteres") || textLower.includes("m\xE1ximo") && textLower.includes("caracteres") || /* Generic ZOD/form required — must be specific, NOT broad instructional text */
-            textLower.includes("campo requerido") || textLower.includes("campo obligatorio") || textLower === "requerido" || textLower === "obligatorio" || textLower.includes("este campo es requerido") || textLower.includes("este campo es obligatorio") || textLower.includes("no puede estar vac\xEDo") || textLower.includes("no puede ser") || textLower.includes("no es v\xE1lido") || textLower.includes("no es correcto") || textLower.includes("formato incorrecto") || textLower.includes("formato inv\xE1lido") || textLower.includes("valor no permitido")) && text.length < 200 && !textLower.includes("recuerda") && !textLower.includes("antes de guardar");
+            textLower.includes("debe ser posterior") || textLower.includes("debe ser anterior") || textLower.includes("debe ser una fecha") || textLower.includes("fecha debe ser") || textLower.includes("posterior o igual a la fecha") || textLower.includes("anterior o igual a la fecha") || textLower.includes("posterior a la fecha") || textLower.includes("anterior a la fecha") || textLower.includes("fecha") && (textLower.includes("actual") || textLower.includes("pasada") || textLower.includes("futura") || textLower.includes("requerida") || textLower.includes("inv\uFFFDlida") || textLower.includes("incorrecta") || textLower.includes("posterior") || textLower.includes("anterior")) || /* ZOD number/range messages */
+            textLower.includes("debe ser un n\uFFFDmero") || textLower.includes("debe ser positivo") || textLower.includes("debe ser negativo") || textLower.includes("m\uFFFDnimo") && textLower.includes("caracteres") || textLower.includes("m\uFFFDximo") && textLower.includes("caracteres") || /* Generic ZOD/form required � must be specific, NOT broad instructional text */
+            textLower.includes("campo requerido") || textLower.includes("campo obligatorio") || textLower === "requerido" || textLower === "obligatorio" || textLower.includes("este campo es requerido") || textLower.includes("este campo es obligatorio") || textLower.includes("no puede estar vac\uFFFDo") || textLower.includes("no puede ser") || textLower.includes("no es v\uFFFDlido") || textLower.includes("no es correcto") || textLower.includes("formato incorrecto") || textLower.includes("formato inv\uFFFDlido") || textLower.includes("valor no permitido")) && text.length < 200 && !textLower.includes("recuerda") && !textLower.includes("antes de guardar");
             const isCriticalSuccess = (textLower.includes("exitosamente") || textLower.includes("guardado") || textLower.includes("creado") || textLower.includes("success") || textLower.includes("correctamente") && text.length < 100) && text.length < 200;
             const isCriticalFeedback = isCriticalFailure || isCriticalSuccess;
             const isFormSelection = tag === "input" && (htmlEl.getAttribute("type") === "radio" || htmlEl.getAttribute("type") === "checkbox") || (role === "radio" || role === "checkbox" || role === "switch");
@@ -2444,8 +3411,8 @@ ${relevantFailures.map((m) => `- ${m.prompt}`).join("\n")}
             let type = "INFO";
             const isErrorClass = classLower.includes("error") || classLower.includes("danger") || classLower.includes("fail");
             const isError = isCriticalFailure || isErrorClass && text.split(" ").length > 2;
-            const isSuccess = classLower.includes("success") || isCriticalSuccess || textLower.includes("\xE9xito");
-            const isTab = role === "tab" || classLower.includes("tab") || classLower.includes("pesta\xF1a");
+            const isSuccess = classLower.includes("success") || isCriticalSuccess || textLower.includes("\uFFFDxito");
+            const isTab = role === "tab" || classLower.includes("tab") || classLower.includes("pesta\uFFFDa");
             if (tag === "input" || tag === "textarea" || tag === "select" || isFormSelection)
               type = "FIELD";
             else if (tag === "button" || role === "button" || tag === "a" || role === "link" || isTab)
@@ -2458,7 +3425,7 @@ ${relevantFailures.map((m) => `- ${m.prompt}`).join("\n")}
               type = isSuccess ? "SUCCESS_MESSAGE" : isError ? "ERROR_MESSAGE" : "MESSAGE";
             }
             if (type.includes("MESSAGE")) {
-              const prefix = isError ? "\u{1F6D1} [ERROR_CR\xCDTICO] " : isSuccess ? "\u2728 [\xC9XITO_DETECTADO] " : "[INFO] ";
+              const prefix = isError ? "?? [ERROR_CR\uFFFDTICO] " : isSuccess ? "? [\uFFFDXITO_DETECTADO] " : "[INFO] ";
               name = prefix + (name || text || "Mensaje del sistema");
             }
             if (type === "ACTION" || type === "FIELD") {
@@ -2510,23 +3477,23 @@ ${relevantFailures.map((m) => `- ${m.prompt}`).join("\n")}
       } catch {
       }
     }
-    console.log(`>>ARCALITY_STATUS>> \u{1F50D} Percepci\xF3n profunda encontr\xF3 ${allComponents.length} componentes`);
+    console.log(`>>ARCALITY_STATUS>> ?? Percepci\uFFFDn profunda encontr\uFFFD ${allComponents.length} componentes`);
     const urlForBlankCheck = this.page.url();
     const isAuthPage = urlForBlankCheck.includes("/login") || urlForBlankCheck.includes("/auth") || urlForBlankCheck.includes("oauth") || urlForBlankCheck.includes("/#/");
     if (allComponents.length < 10 && !isAuthPage) {
       const bodyTextLength = await this.page.evaluate(() => document.body.innerText.trim().length).catch(() => 999);
       if (bodyTextLength < 80) {
         console.warn(`
-\u26A0\uFE0F [BLANK_STATE] Primera medici\xF3n: ${allComponents.length} componentes, ${bodyTextLength} chars. Esperando re-render...`);
+?? [BLANK_STATE] Primera medici\uFFFDn: ${allComponents.length} componentes, ${bodyTextLength} chars. Esperando re-render...`);
         await this.page.waitForTimeout(2500);
         const bodyTextLength2 = await this.page.evaluate(() => document.body.innerText.trim().length).catch(() => 999);
         const components2 = await this.page.evaluate(() => document.querySelectorAll("a, button, input, select, textarea").length).catch(() => 999);
         if (bodyTextLength2 < 80 && components2 < 10) {
           console.error(`
-\u{1F6D1} [BLANK_STATE_CRASH] Vista en blanco confirmada tras espera (Comps: ${components2}, Texto: ${bodyTextLength2} chars). URL: ${urlForBlankCheck}`);
-          throw new Error(`[BLANK_STATE_CRASH] El portal carg\xF3 en blanco. Esto es un fallo de renderizado del portal, no de Arcality.`);
+?? [BLANK_STATE_CRASH] Vista en blanco confirmada tras espera (Comps: ${components2}, Texto: ${bodyTextLength2} chars). URL: ${urlForBlankCheck}`);
+          throw new Error(`[BLANK_STATE_CRASH] El portal carg\uFFFD en blanco. Esto es un fallo de renderizado del portal, no de Arcality.`);
         } else {
-          console.log(`>>ARCALITY_STATUS>> \u2705 [BLANK_STATE] Falsa alarma. P\xE1gina recuper\xF3 contenido tras espera (${components2} comps, ${bodyTextLength2} chars).`);
+          console.log(`>>ARCALITY_STATUS>> ? [BLANK_STATE] Falsa alarma. P\uFFFDgina recuper\uFFFD contenido tras espera (${components2} comps, ${bodyTextLength2} chars).`);
         }
       }
     }
@@ -2608,7 +3575,7 @@ ${relevantFailures.map((m) => `- ${m.prompt}`).join("\n")}
         }
       }
     } catch (e) {
-      console.log(`>>ARCALITY_STATUS>> \u26A0\uFE0F Error en hook de ingesta: ${e.message}`);
+      console.log(`>>ARCALITY_STATUS>> ?? Error en hook de ingesta: ${e.message}`);
     }
     return {
       url,
@@ -2692,18 +3659,18 @@ ${JSON.stringify(diagnosticPayload, null, 2)}`
     }
   }
   /**
-   * Busca una acción sugerida en la memoria SIN usar tokens.
+   * 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 fs7 = require("fs");
-      const path7 = require("path");
-      const memoryFile = path7.join(this.contextDir, "memoria-agente.json");
-      if (!fs7.existsSync(memoryFile)) {
+      const fs8 = require("fs");
+      const path9 = require("path");
+      const memoryFile = path9.join(this.contextDir, "memoria-agente.json");
+      if (!fs8.existsSync(memoryFile)) {
         return null;
       }
-      const memories = JSON.parse(fs7.readFileSync(memoryFile, "utf8"));
+      const memories = JSON.parse(fs8.readFileSync(memoryFile, "utf8"));
       const state = await this.getPageState();
       const currentUrl = this.page.url();
       const extractCriticalKeywords = (text) => {
@@ -2717,8 +3684,8 @@ ${JSON.stringify(diagnosticPayload, null, 2)}`
           keywords.add("tercera");
         if (lower.includes("cuarta"))
           keywords.add("cuarta");
-        if (lower.includes("\xFAltima"))
-          keywords.add("\xFAltima");
+        if (lower.includes("\uFFFDltima"))
+          keywords.add("\uFFFDltima");
         if (lower.includes("first"))
           keywords.add("primera");
         if (lower.includes("second"))
@@ -2728,11 +3695,11 @@ ${JSON.stringify(diagnosticPayload, null, 2)}`
         if (lower.includes("fourth"))
           keywords.add("cuarta");
         if (lower.includes("last"))
-          keywords.add("\xFAltima");
+          keywords.add("\uFFFDltima");
         return keywords;
       };
       const currentKeywords = extractCriticalKeywords(prompt);
-      const currentVerbs = ["elimina", "borra", "quita", "delete", "remove", "crea", "nueva", "a\xF1ade", "add", "create", "new", "edita", "modifica", "cambia", "edit", "update"].filter((v) => prompt.toLowerCase().includes(v));
+      const currentVerbs = ["elimina", "borra", "quita", "delete", "remove", "crea", "nueva", "a\uFFFDade", "add", "create", "new", "edita", "modifica", "cambia", "edit", "update"].filter((v) => prompt.toLowerCase().includes(v));
       const matchingRun = memories.filter((m) => m.success && m.steps_data && m.steps_data[historyLength]).reverse().find((m) => {
         const memPrompt = (m.prompt || "").toLowerCase();
         const currentPrompt = prompt.toLowerCase();
@@ -2744,7 +3711,7 @@ ${JSON.stringify(diagnosticPayload, null, 2)}`
         const matchRatio = matches / words.length;
         if (matchRatio < 0.85)
           return false;
-        const memVerbs = ["elimina", "borra", "quita", "delete", "remove", "crea", "nueva", "a\xF1ade", "add", "create", "new", "edita", "modifica", "cambia", "edit", "update"].filter((v) => memPrompt.includes(v));
+        const memVerbs = ["elimina", "borra", "quita", "delete", "remove", "crea", "nueva", "a\uFFFDade", "add", "create", "new", "edita", "modifica", "cambia", "edit", "update"].filter((v) => memPrompt.includes(v));
         const hasSharedVerb = currentVerbs.some((cv) => memVerbs.includes(cv));
         const hasOppositeIntent = currentVerbs.some((v) => ["elimina", "borra", "delete"].includes(v)) && memVerbs.some((v) => ["crea", "nueva", "create", "new"].includes(v)) || currentVerbs.some((v) => ["crea", "nueva", "create", "new"].includes(v)) && memVerbs.some((v) => ["elimina", "borra", "delete"].includes(v));
         if (hasOppositeIntent)
@@ -2805,21 +3772,21 @@ ${JSON.stringify(diagnosticPayload, null, 2)}`
         }
         const foundComponent = bestMatchScore >= 40 ? bestMatch : null;
         if (!foundComponent && memStep.action_data?.action !== "wait") {
-          console.log(`>>ARCALITY_STATUS>> \u{1F50D} Descartado (Componente visual no encontrado: ${memStep.componentName})`);
+          console.log(`>>ARCALITY_STATUS>> ?? Descartado (Componente visual no encontrado: ${memStep.componentName})`);
           return null;
         }
         if (foundComponent && memStep.action_data?.action === "fill") {
           const compType = (foundComponent.type || "").toLowerCase();
           const compName = (foundComponent.name || "").toLowerCase();
-          const looksLikeDropdown = compType.includes("select") || compType.includes("combobox") || compName.includes("tipo") || compName.includes("type") || compName.includes("categor\xEDa") || compName.includes("estado") || compName.includes("frecuencia") || compName.includes("alcance");
+          const looksLikeDropdown = compType.includes("select") || compType.includes("combobox") || compName.includes("tipo") || compName.includes("type") || compName.includes("categor\uFFFDa") || compName.includes("estado") || compName.includes("frecuencia") || compName.includes("alcance");
           if (looksLikeDropdown) {
-            console.log(`>>ARCALITY_STATUS>> \u{1F50D} Descartado (fill en dropdown detectado: ${foundComponent.name}). Delegando a IA.`);
+            console.log(`>>ARCALITY_STATUS>> ?? Descartado (fill en dropdown detectado: ${foundComponent.name}). Delegando a IA.`);
             return null;
           }
         }
         const memCompName = memStep.componentName || "";
         if (memCompName.length > 80) {
-          console.log(`>>ARCALITY_STATUS>> \u{1F50D} Descartado (Mensaje enorme o nombre inconsistente: ${memCompName.substring(0, 20)}...)`);
+          console.log(`>>ARCALITY_STATUS>> ?? Descartado (Mensaje enorme o nombre inconsistente: ${memCompName.substring(0, 20)}...)`);
           return null;
         }
         if (!memCompName || memCompName.length < 3) {
@@ -2829,18 +3796,18 @@ ${JSON.stringify(diagnosticPayload, null, 2)}`
           let actionData = { ...memStep.action_data };
           if (actionData.value === "{{secret}}") {
             const cName = (foundComponent.name || "").toLowerCase();
-            if (cName.includes("password") || cName.includes("contrase\xF1a")) {
+            if (cName.includes("password") || cName.includes("contrase\uFFFDa")) {
               actionData.value = "Qa_Test123!";
             } else if (cName.includes("email") || cName.includes("correo")) {
               actionData.value = `qa_${Date.now()}@test.com`;
             } else if (cName.includes("descrip")) {
-              actionData.value = `Descripci\xF3n QA Automatizada ${Date.now()}`;
+              actionData.value = `Descripci\uFFFDn QA Automatizada ${Date.now()}`;
             } else {
               actionData.value = `QA_Test_${Date.now()}`;
             }
           }
           return {
-            thought: `[GU\xCDA DE \xC9XITO] Reutilizando paso maestro aprendido: ${actionData.action} en ${foundComponent.name}`,
+            thought: `[GU\uFFFDA DE \uFFFDXITO] Reutilizando paso maestro aprendido: ${actionData.action} en ${foundComponent.name}`,
             actions: [{
               ...actionData,
               idx: foundComponent.idx,
@@ -2962,12 +3929,18 @@ ${JSON.stringify(diagnosticPayload, null, 2)}`
       };
     }
     const credentialsContext = process.env.LOGIN_USER && process.env.LOGIN_PASSWORD ? `
-\u{1F511} QA CREDENTIALS (Use if login is needed):
+?? QA CREDENTIALS (Use if login is needed):
 - User: ${process.env.LOGIN_USER}
 - Password: ${process.env.LOGIN_PASSWORD} 
 ` : "";
     const memoryContext = this.loadMemory(prompt);
     const skillsContext = this.loadSkills();
+    const databaseValidationEnabled = ["1", "true", "yes", "on"].includes(String(process.env.ARCALITY_DB_ENABLED || "").toLowerCase());
+    const databaseProfile = process.env.ARCALITY_DB_PROFILE || "qa_local";
+    const databaseContext = databaseValidationEnabled ? `
+# DATABASE VALIDATION CONTEXT
+PostgreSQL validation is enabled for profile "${databaseProfile}". If the mission asks to corroborate backend persistence or database state, use \`validate_database_state\` after the relevant UI action succeeds. If you need to verify query_id, params, connectivity, or returned rows before asserting, use \`preview_db_validation\`. Use only query_id values from the local catalog; never invent raw SQL.
+` : "";
     let assetContext = "";
     try {
       const { formatUploadAssetContext: formatUploadAssetContext2 } = (init_asset_resolver(), __toCommonJS(asset_resolver_exports));
@@ -2980,7 +3953,7 @@ ${JSON.stringify(diagnosticPayload, null, 2)}`
       const runtimeProjectRoot = process.env.ARCALITY_PROJECT_ROOT || process.cwd();
       const ctx = getProjectContext(runtimeProjectRoot);
       projectInfo = `
-\u{1F3D7}\uFE0F PROJECT CONTEXT:
+??? PROJECT CONTEXT:
 - Name: ${ctx.name}
 - Tech Stack: ${ctx.framework}
 - Environment: ${process.env.NODE_ENV || "development"}
@@ -2993,11 +3966,11 @@ ${JSON.stringify(diagnosticPayload, null, 2)}`
       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 (${backendContextData.rules?.length || 0} reglas, ${backendContextData.fields?.length || 0} campos).`);
+          console.log(`>>ARCALITY_STATUS>> ?? 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}`);
+        console.log(`>>ARCALITY_STATUS>> ?? Error en hook de contexto: ${e.message}`);
     }
     let customUserContext = "";
     try {
@@ -3020,7 +3993,7 @@ ${JSON.stringify(diagnosticPayload, null, 2)}`
           }
         }
         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.`);
+          console.log(`>>ARCALITY_STATUS>> Pol\uFFFDtica efectiva de contexto: local qa-context > memoria backend > heur\uFFFDsticas base.`);
         }
         this.qaContextStatusLogged = true;
       }
@@ -3035,22 +4008,22 @@ ${JSON.stringify(diagnosticPayload, null, 2)}`
       {
         type: "text",
         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.
+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 \uFFFD guessing and blind retries are UNACCEPTABLE.
 
 `
       },
       {
         type: "text",
         text: `
-# METHODOLOGY (MANDATORY \u2014 Follow in order)
+# METHODOLOGY (MANDATORY \uFFFD Follow in order)
 Every turn, you MUST follow these 4 phases:
 
 ## Phase 1: OBSERVE
 - Read ALL components in CURRENT COMPONENTS carefully.
-- Check the URL \u2014 are you on the right page?
-- Read HISTORY \u2014 what have you already done? Don't repeat actions.
-- Look for MESSAGE components \u2014 errors ([ERROR_CR\xCDTICO]) or success messages.
-- If you see [INFERRED] in any component name \u2192 that name is UNRELIABLE. You MUST call \`inspect_element_details\` on it BEFORE interacting.
+- Check the URL \uFFFD are you on the right page?
+- Read HISTORY \uFFFD what have you already done? Don't repeat actions.
+- Look for MESSAGE components \uFFFD errors ([ERROR_CR\uFFFDTICO]) or success messages.
+- If you see [INFERRED] in any component name ? that name is UNRELIABLE. You MUST call \`inspect_element_details\` on it BEFORE interacting.
 
 ## Phase 2: PLAN
 - Based on your observations, decide: What is the ONE next meaningful step toward completing the mission?
@@ -3065,10 +4038,10 @@ Every turn, you MUST follow these 4 phases:
   - **STEP 1 (MANDATORY)**: Click the dropdown/combobox trigger to OPEN it. Wait for the list to appear.
   - **STEP 2 (MANDATORY, SAME or NEXT turn)**: Click the desired option directly (\`[li]\` or \`[option]\`). Do NOT use \`fill\` to type text.
   - **STEP 3**: If more fields remain in the same form section, do NOT group them in the same turn. Wait for re-render first.
-  - **NEVER** insert a \`wait\` action between clicking the trigger and clicking the option \u2014 complete both in one turn.
+  - **NEVER** insert a \`wait\` action between clicking the trigger and clicking the option \uFFFD complete both in one turn.
   - **STRICTLY FORBIDDEN**: Sending Escape repeatedly. After selecting an option, click the NEXT logical button directly.
-- For menus: Click menu icon \u2192 WAIT for next turn \u2192 Click option.
-- For \`<input type="date">\` native fields: NEVER use \`fill\`. ALWAYS use \`interact_native_control\` with value in YYYY-MM-DD format. Do this ONCE per field. If it fails, do NOT retry \u2014 move on and click Siguiente to see the validation message.
+- For menus: Click menu icon ? WAIT for next turn ? Click option.
+- For \`<input type="date">\` native fields: NEVER use \`fill\`. ALWAYS use \`interact_native_control\` with value in YYYY-MM-DD format. Do this ONCE per field. If it fails, do NOT retry \uFFFD move on and click Siguiente to see the validation message.
 
 ## Phase 4: VERIFY
 - After critical actions (SAVE/CREATE/DELETE), verify the result:
@@ -3087,26 +4060,28 @@ These are NOT optional. You MUST use these tools in these situations:
 | Element name has [INFERRED] | \`inspect_element_details\` | BEFORE interacting with it |
 | Before clicking SAVE/GUARDAR | \`validate_element_state\` | To confirm button is enabled |
 | After successful SAVE | \`extract_table_data\` | To verify record was created |
+| Mission asks to validate PostgreSQL/backend data | \`validate_database_state\` | AFTER the relevant UI action succeeds, using a query_id from the local catalog |
+| Need to dry-run a database query_id or inspect returned rows before asserting | \`preview_db_validation\` | BEFORE the mission or before adding expect rules |
 | UI is frozen/unresponsive | \`capture_console_errors\` | To check for JS errors |
 | Mission mentions a concrete route like '/counter' and current URL is different, or the route has no visible menu item | \`navigate_to_url\` | IMMEDIATELY instead of improvising clicks |
 | 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 |
+| Masked numeric/code input, OTP/PIN/CLABE/INE identifier, or prompt says "manualmente", "d\uFFFDgito por d\uFFFDgito", "car\uFFFDcter por car\uFFFDcter" | \`type_sequentially\` | After ONE focus attempt on the field; do not keep clicking |
+| Time/Date/Color picker field | \`interact_native_control\` | INSTEAD of fill \uFFFD 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 |
-| Dropdown selected but still visually open | \`send_keyboard_event\` (Tab) | If Escape did not close it \u2014 force field to lose focus |
+| Need to close dropdown/menu | \`send_keyboard_event\` (Escape) | IMMEDIATELY after selecting any option \uFFFD MANDATORY |
+| Dropdown selected but still visually open | \`send_keyboard_event\` (Tab) | If Escape did not close it \uFFFD force field to lose focus |
 | Navigate between form sections | \`send_keyboard_event\` (Tab) | To move focus between fields |
 
 # CRITICAL RULES
 1. **NEVER BLIND-RETRY**: If an action fails, you MUST investigate with \`inspect_element_details\` before retrying. Repeating the exact same failed action is FORBIDDEN.
 2. **NO REPEAT ACTIONS**: Check HISTORY. If you already filled a field or clicked a button, do NOT do it again unless the UI clearly reset OR the button belongs to a different step/modal/section mentioned in the mission (e.g., Save in modal vs Save in main form).
 3. **GROUP ACTIONS CAREFULLY**: You MUST group non-conflicting actions in a single turn to save time and tokens.
-   - You can \`fill\` multiple plain text inputs in the SAME turn (Nombre, Descripci\xF3n, etc.).
+   - You can \`fill\` multiple plain text inputs in the SAME turn (Nombre, Descripci\uFFFDn, etc.).
    - You CANNOT mix dropdown selection with filling other fields in the same turn (React re-renders invalidate idx).
-   - For \`<input type="date">\` fields: use \`interact_native_control\` ONCE per field \u2014 do NOT retry with \`fill\` or \`click\`.
-   - NEVER insert a \`wait\` action between related dropdown steps (click trigger \u2192 click option). It breaks the sequence.
+   - For \`<input type="date">\` fields: use \`interact_native_control\` ONCE per field \uFFFD do NOT retry with \`fill\` or \`click\`.
+   - NEVER insert a \`wait\` action between related dropdown steps (click trigger ? click option). It breaks the sequence.
 
 3. **CURRENT STATE > MEMORY**: What you see in CURRENT COMPONENTS is the truth. SUCCESS MEMORY is a guide, not gospel.
 4. **PAGE TRANSITIONS**: If URL contains '/edit' or you see a 'Save' button, you ARE in the edit view. Don't go back.
@@ -3117,8 +4092,8 @@ These are NOT optional. You MUST use these tools in these situations:
    - If the dropdown selection was the LAST step in the form, you CAN immediately click Siguiente/Guardar in the same turn.
    - **ESCAPE RULE**: You may send Escape ONCE after selecting to help close the dropdown. If you already sent Escape and the form still shows the same state, DO NOT send Escape again. Click \`Siguiente\` or \`Guardar\` directly to proceed.
    - **VALIDATION ERRORS**: If Siguiente reports a validation error on a dropdown field, THEN use \`inspect_element_details\` to understand the field's selector and interact with it precisely. Not before.
-6. **ERROR HANDLING**: If you see '\u{1F6D1} [ERROR_CR\xCDTICO]', STOP everything. Analyze the error, fix the data, then retry.
-6b. **DUPLICATE / REPEATED VALUE ERROR \u2014 MANDATORY PROTOCOL**:
+6. **ERROR HANDLING**: If you see '?? [ERROR_CR\uFFFDTICO]', STOP everything. Analyze the error, fix the data, then retry.
+6b. **DUPLICATE / REPEATED VALUE ERROR \uFFFD MANDATORY PROTOCOL**:
    - If HISTORY contains a line with "ERROR VISIBLE EN PANTALLA" or "ERROR POST-GUARDADO" with words like "repetido", "duplicado", "ya existe", or "already exists":
      1. You MUST identify WHICH field caused the duplication (usually the main name/title field).
      2. You MUST use \`fill\` to REPLACE that field's value with a NEW unique value. Add a numeric suffix like \`_${(/* @__PURE__ */ new Date()).getMinutes()}${(/* @__PURE__ */ new Date()).getSeconds()}\` or a short random number.
@@ -3136,9 +4111,9 @@ These are NOT optional. You MUST use these tools in these situations:
 11. **NEGATIVE TESTING**: If mission expects an error (e.g., "verifica que no se pueda guardar sin campos"), and you see that error, the mission is SUCCESS. Use \`finish: true\`.
 12. **GUIDE CONFLICT**: If SUCCESS MEMORY disagrees with what you see on screen, ABANDON the memory and trust your eyes.
 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.
+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\uFFFDn", 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":
+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\uFFFDmero por n\uFFFDmero", "d\uFFFDgito por d\uFFFDgito", or "car\uFFFDcter por car\uFFFDcter":
    - 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.
@@ -3146,53 +4121,53 @@ These are NOT optional. You MUST use these tools in these situations:
 
 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.
+   - If no asset matches the required type, use the value \`"placeholder:image/banner"\` \uFFFD 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):
+When a form is divided into numbered steps (e.g., Step 1 ? Step 2 ? Step 3):
 
-1. **VALIDATION ERROR ON ADVANCE**: If you click "Next/Siguiente" and the UI DOES NOT advance to the next step, AND you see a \u{1F6D1} [ERROR_CR\xCDTICO], you must fix the data on the CURRENT step. DO NOT GO BACK to previous steps simply because you see an error, unless the error explicitly states that a previous step's data is invalid.
+1. **VALIDATION ERROR ON ADVANCE**: If you click "Next/Siguiente" and the UI DOES NOT advance to the next step, AND you see a ?? [ERROR_CR\uFFFDTICO], you must fix the data on the CURRENT step. DO NOT GO BACK to previous steps simply because you see an error, unless the error explicitly states that a previous step's data is invalid.
 
-2. **DATE VALIDATION ERRORS \u2014 MANDATORY PROTOCOL (ZOD-AWARE)**:
+2. **DATE VALIDATION ERRORS \uFFFD MANDATORY PROTOCOL (ZOD-AWARE)**:
    - ZOD generates Spanish validation messages such as:
      - "La fecha de inicio debe ser posterior o igual a la fecha actual."
      - "La fecha debe ser una fecha futura."
      - "Debe ser posterior a la fecha de inicio."
      - "El valor debe ser mayor o igual a X."
-   - ANY \u{1F6D1} [ERROR_CR\xCDTICO] containing FECHA + (POSTERIOR/ANTERIOR/ACTUAL/PASADA/FUTURA) is a **ZOD DATE VALIDATION ERROR**.
+   - ANY ?? [ERROR_CR\uFFFDTICO] containing FECHA + (POSTERIOR/ANTERIOR/ACTUAL/PASADA/FUTURA) is a **ZOD DATE VALIDATION ERROR**.
    - **RECOVERY PROTOCOL** (follow in order, NEVER skip):
-     1. STOP \u2014 do NOT click Save/Siguiente again with the same data.
+     1. STOP \uFFFD do NOT click Save/Siguiente again with the same data.
      2. Identify which wizard step contains the failing date field (check HISTORY).
      3. If you are NOT on that step, click the Back/Anterior button to return to it.
      4. Locate the date input using \`validate_element_state\` with 'has_value' to confirm its current (bad) value.
-     5. Clear and re-fill the date using \`interact_native_control\` with control_type \`'date'\` and a value \u2265 TODAY in YYYY-MM-DD format.
-     6. TODAY: \`${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}\` \u2014 use this exact expression to compute the date dynamically.
+     5. Clear and re-fill the date using \`interact_native_control\` with control_type \`'date'\` and a value = TODAY in YYYY-MM-DD format.
+     6. TODAY: \`${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}\` \uFFFD use this exact expression to compute the date dynamically.
      7. After fixing ALL date fields, advance through each wizard step again.
 
 3. **NEVER LOOP ON THE SAME STEP**: If you've been on the same wizard step for 3+ turns without advancing, go back one step and verify the data is correct before trying to advance again.
 
 4. **STEP VERIFICATION**: Before clicking Next/Save on any step, VERIFY that date fields have future-or-today dates. Use \`validate_element_state\` with 'has_value' to confirm.
 
-5. **FINAL PREVIEW STEP**: If you reach a final step like "Previsualizaci\xF3n", "Resumen", or see a "Terminar" / "Finalizar" button, your objective is ALMOST COMPLETE. Do NOT go back to previous steps just because you see read-only data. Click the final submit button ("Terminar", "Guardar", "Finalizar") to complete the mission.
+5. **FINAL PREVIEW STEP**: If you reach a final step like "Previsualizaci\uFFFDn", "Resumen", or see a "Terminar" / "Finalizar" button, your objective is ALMOST COMPLETE. Do NOT go back to previous steps just because you see read-only data. Click the final submit button ("Terminar", "Guardar", "Finalizar") to complete the mission.
 
-6. **DATE FIELD \u2014 ONE SHOT RULE**: For any \`<input type="date">\`, you get EXACTLY ONE attempt with \`interact_native_control\`. If it does not stick (field shows empty on next perception), do NOT retry the date. Instead: a) use \`send_keyboard_event\` to type the date digit by digit (e.g., "0", "5", "0", "5", "2", "0", "2", "6"), OR b) click \`Siguiente\` and see if ZOD validates it. If ZOD rejects it, THEN and ONLY THEN come back to fix. Looping 3+ times on the same date field is FORBIDDEN.
+6. **DATE FIELD \uFFFD ONE SHOT RULE**: For any \`<input type="date">\`, you get EXACTLY ONE attempt with \`interact_native_control\`. If it does not stick (field shows empty on next perception), do NOT retry the date. Instead: a) use \`send_keyboard_event\` to type the date digit by digit (e.g., "0", "5", "0", "5", "2", "0", "2", "6"), OR b) click \`Siguiente\` and see if ZOD validates it. If ZOD rejects it, THEN and ONLY THEN come back to fix. Looping 3+ times on the same date field is FORBIDDEN.
 
-7. **MODAL REWARD COMBOBOX**: In the rewards modal ("Configurar Recompensas del Juego"), the "Tipo de recompensa" dropdown is a \`[div]\` trigger, NOT an \`[input]\`. Always use 2 turns: Turn A = Click the trigger div to open the option list. Turn B = Click the specific option (e.g., \`[li] Puntos\`, \`[li] Cup\xF3n\`). Do NOT use \`fill\` on this field.
+7. **MODAL REWARD COMBOBOX**: In the rewards modal ("Configurar Recompensas del Juego"), the "Tipo de recompensa" dropdown is a \`[div]\` trigger, NOT an \`[input]\`. Always use 2 turns: Turn A = Click the trigger div to open the option list. Turn B = Click the specific option (e.g., \`[li] Puntos\`, \`[li] Cup\uFFFDn\`). Do NOT use \`fill\` on this field.
 
-8. **MODAL SELECTION PROTOCOL (CRITICAL)**: In selection modals (e.g., "Selecciona cup\xF3n"), you MUST select an item BEFORE clicking "Seleccionar" or "Confirmar". To select an item, click on ANY visible element within the item's row: the radio button, the item's name, OR its status label (e.g., the text "Activo" next to a coupon name). Clicking the confirm button without a prior selection WILL FAIL. If you do NOT see a radio button IDX in the component list, click the item's STATUS text (like "Activo") or its NAME text instead \u2014 this is the EXPECTED behavior for custom UI components.
+8. **MODAL SELECTION PROTOCOL (CRITICAL)**: In selection modals (e.g., "Selecciona cup\uFFFDn"), you MUST select an item BEFORE clicking "Seleccionar" or "Confirmar". To select an item, click on ANY visible element within the item's row: the radio button, the item's name, OR its status label (e.g., the text "Activo" next to a coupon name). Clicking the confirm button without a prior selection WILL FAIL. If you do NOT see a radio button IDX in the component list, click the item's STATUS text (like "Activo") or its NAME text instead \uFFFD this is the EXPECTED behavior for custom UI components.
 
-9. **RADIO BUTTON FALLBACK**: If you cannot find a dedicated radio button element for a list item, do NOT loop. Instead: a) Click the item's visible text (name, status, or any text in its row). b) If that doesn't work, try clicking the row container element. c) NEVER use the search box to "select" an item \u2014 the search box only filters the list, it does NOT select.
+9. **RADIO BUTTON FALLBACK**: If you cannot find a dedicated radio button element for a list item, do NOT loop. Instead: a) Click the item's visible text (name, status, or any text in its row). b) If that doesn't work, try clicking the row container element. c) NEVER use the search box to "select" an item \uFFFD the search box only filters the list, it does NOT select.
 
-10. **DROPDOWN TOGGLE WARNING (CRITICAL)**: Clicking a dropdown/combobox trigger TOGGLES it: 1st click = open, 2nd click = CLOSE, 3rd click = open again. If you clicked a dropdown trigger and do NOT see options in the next turn, do NOT click it again \u2014 you will just close it! Instead, use \`send_keyboard_event\` with "ArrowDown" to open/navigate the dropdown, then "Enter" to select.
+10. **DROPDOWN TOGGLE WARNING (CRITICAL)**: Clicking a dropdown/combobox trigger TOGGLES it: 1st click = open, 2nd click = CLOSE, 3rd click = open again. If you clicked a dropdown trigger and do NOT see options in the next turn, do NOT click it again \uFFFD you will just close it! Instead, use \`send_keyboard_event\` with "ArrowDown" to open/navigate the dropdown, then "Enter" to select.
 
 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. **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.`,
+13. **ERROR STOP PROTOCOL (CRITICAL)**: If you see a message starting with \`?? [ERROR_CR\uFFFDTICO]\` or \`?? 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" }
       },
       {
@@ -3202,6 +4177,7 @@ When a form is divided into numbered steps (e.g., Step 1 \u2192 Step 2 \u2192 St
 ${prompt}
 
 ${projectInfo}
+${databaseContext}
 ${skillsContext}
 ${customUserContext}
 ${memoryContext}
@@ -3255,7 +4231,7 @@ ${history.slice(-25).join("\n") || "None"}`
         ]
       }
     ];
-    console.log(`>>ARCALITY_STATUS>> \u{1F9E0} Arcality est\xE1 procesando la visi\xF3n...`);
+    console.log(`>>ARCALITY_STATUS>> ?? Arcality est\uFFFD procesando la visi\uFFFDn...`);
     const startTime = Date.now();
     let totalUsage = { input_tokens: 0, output_tokens: 0, cache_creation_input_tokens: 0, cache_read_input_tokens: 0 };
     for (let turn = 0; turn < 10; turn++) {
@@ -3266,7 +4242,7 @@ ${history.slice(-25).join("\n") || "None"}`
         const isProxyMode = !!process.env.ARCALITY_API_URL;
         const endpointUrl = isProxyMode ? `${process.env.ARCALITY_API_URL}/api/v1/ai/proxy` : "https://api.anthropic.com/v1/messages";
         const displayTurn = stepCount !== void 0 ? stepCount : turn + 1;
-        console.log(`>>ARCALITY_STATUS>> \u{1F4E1} Llamando a: ${endpointUrl} (turno IA ${displayTurn}${turn > 0 ? `, ciclo interno ${turn + 1}` : ""})`);
+        console.log(`>>ARCALITY_STATUS>> ?? Llamando a: ${endpointUrl} (turno IA ${displayTurn}${turn > 0 ? `, ciclo interno ${turn + 1}` : ""})`);
         const headers = {
           "Content-Type": "application/json"
         };
@@ -3306,13 +4282,13 @@ ${history.slice(-25).join("\n") || "None"}`
         if (response.ok)
           break;
         const errorText = await response.text();
-        console.log(`>>ARCALITY_STATUS>> \u274C API Error ${response.status}: ${errorText.substring(0, 500)}`);
+        console.log(`>>ARCALITY_STATUS>> ? API Error ${response.status}: ${errorText.substring(0, 500)}`);
         const isTransient = response.status === 529 || response.status === 429 || response.status === 503;
         if (isTransient && retryCount < maxRetries) {
           retryCount++;
           const delay = Math.pow(2, retryCount) * 1e3;
           console.log(`
->>ARCALITY_STATUS>> \u26A0\uFE0F Arcality est\xE1 saturado (${response.status}). Reintentando...`);
+>>ARCALITY_STATUS>> ?? Arcality est\uFFFD saturado (${response.status}). Reintentando...`);
           await new Promise((resolve2) => setTimeout(resolve2, delay));
           continue;
         }
@@ -3334,7 +4310,7 @@ ${history.slice(-25).join("\n") || "None"}`
       const textResponse = message.content.find((c) => c.type === "text")?.text || "";
       if (toolCalls.length === 0) {
         console.log(`(${((Date.now() - startTime) / 1e3).toFixed(1)}s)`);
-        console.log(`>>ARCALITY_STATUS>> \u26A0\uFE0F Arcality devolvi\xF3 texto sin acci\xF3n. Reinyectando instrucci\xF3n mandatoria...`);
+        console.log(`>>ARCALITY_STATUS>> ?? Arcality devolvi\uFFFD texto sin acci\uFFFDn. Reinyectando instrucci\uFFFDn mandatoria...`);
         anthropicMessages.push({
           role: "user",
           content: [{ type: "text", text: `MANDATORY: You MUST call one of the available tools right now. You are NOT allowed to return plain text only. If you are unsure, call 'perform_ui_actions' with the most logical next action based on the mission and history. If you are truly stuck, call 'report_inability_to_proceed'. DO NOT return text without a tool call.` }]
@@ -3354,7 +4330,7 @@ ${history.slice(-25).join("\n") || "None"}`
         } else if (toolName === "inspect_element_details") {
           const idx = toolInput.idx;
           const c = state.components.find((comp) => comp.idx === idx);
-          console.log(`>>ARCALITY_STATUS>> \u{1F50D} Investigando IDX:${idx}...`);
+          console.log(`>>ARCALITY_STATUS>> ?? Investigando IDX:${idx}...`);
           let details = "Element not found or no longer present.";
           if (c) {
             try {
@@ -3379,11 +4355,11 @@ ${history.slice(-25).join("\n") || "None"}`
           }
           toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: details });
         } else if (toolName === "report_application_bug") {
-          console.error(`\u{1F41B} [BUG DETECTED] ${toolInput.bug_description}`);
+          console.error(`?? [BUG DETECTED] ${toolInput.bug_description}`);
           try {
             const url = this.page.url();
             await this.knowledgeService.saveRule(
-              "Validaci\xF3n Detectada (Auto-Learning)",
+              "Validaci\uFFFDn Detectada (Auto-Learning)",
               `Error: ${toolInput.bug_description}. Se esperaba: ${toolInput.expected_behavior}`,
               "WARNING",
               url
@@ -3395,9 +4371,9 @@ ${history.slice(-25).join("\n") || "None"}`
             const shortDesc = toolInput.bug_description.length > 80 ? toolInput.bug_description.substring(0, 80).trimEnd() + "..." : toolInput.bug_description;
             const bugTitle = `[QA Bug] ${shortDesc}`;
             const bugDescription = [
-              `**Bug detectado autom\xE1ticamente por Arcality QA**`,
+              `**Bug detectado autom\uFFFDticamente por Arcality QA**`,
               ``,
-              `**Descripci\xF3n:** ${toolInput.bug_description}`,
+              `**Descripci\uFFFDn:** ${toolInput.bug_description}`,
               `**Comportamiento esperado:** ${toolInput.expected_behavior}`,
               `**Comportamiento actual:** ${toolInput.actual_behavior}`,
               `**URL afectada:** ${this.page.url()}`,
@@ -3415,9 +4391,9 @@ ${history.slice(-25).join("\n") || "None"}`
             const shortDesc = toolInput.bug_description.length > 80 ? toolInput.bug_description.substring(0, 80).trimEnd() + "..." : toolInput.bug_description;
             const bugTitle = `[QA Bug] ${shortDesc}`;
             const bugDescription = [
-              `**Bug detectado autom\xE1ticamente por Arcality QA**`,
+              `**Bug detectado autom\uFFFDticamente por Arcality QA**`,
               ``,
-              `**Descripci\xF3n:** ${toolInput.bug_description}`,
+              `**Descripci\uFFFDn:** ${toolInput.bug_description}`,
               `**Comportamiento esperado:** ${toolInput.expected_behavior}`,
               `**Comportamiento actual:** ${toolInput.actual_behavior}`,
               `**URL afectada:** ${this.page.url()}`,
@@ -3430,7 +4406,7 @@ ${history.slice(-25).join("\n") || "None"}`
           return {
             thought: `DISCULPA: ${toolInput.confusion_reason}
 
-\u{1F4A1} SUGERENCIA: ${toolInput.prompt_suggestion}`,
+?? SUGERENCIA: ${toolInput.prompt_suggestion}`,
             actions: [],
             finish: true,
             usage: totalUsage
@@ -3496,7 +4472,7 @@ ${history.slice(-25).join("\n") || "None"}`
           toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: result });
         } else if (toolName === "extract_table_data") {
           const { table_identifier, max_rows = 50 } = toolInput;
-          console.log(`>>ARCALITY_STATUS>> \u{1F4CA} Extrayendo tabla: ${table_identifier}...`);
+          console.log(`>>ARCALITY_STATUS>> ?? Extrayendo tabla: ${table_identifier}...`);
           try {
             const tableData = await this.page.evaluate(({ identifier, limit }) => {
               const findTable = () => {
@@ -3526,6 +4502,107 @@ ${history.slice(-25).join("\n") || "None"}`
           } catch (e) {
             toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Error extracting: ${e.message}` });
           }
+        } else if (toolName === "validate_database_state") {
+          console.log(`>>ARCALITY_STATUS>> [DB] Validando estado en PostgreSQL: ${toolInput.query_id}...`);
+          try {
+            const report = await executeDatabaseValidation(toolInput);
+            if (this.testInfo) {
+              await this.testInfo.attach("database_validation_report", {
+                body: Buffer.from(JSON.stringify(report, null, 2), "utf-8"),
+                contentType: "application/json"
+              });
+            }
+            const summary = report.passed ? `Database validation passed: ${report.name}` : `Database validation failed: ${report.name}`;
+            toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `${summary}
+${JSON.stringify(report, null, 2)}` });
+          } catch (e) {
+            const report = {
+              type: "database_validation_report",
+              status: "failed",
+              passed: false,
+              summary: { total: 1, passed: 0, failed: 1 },
+              validations: [{
+                name: toolInput.name || toolInput.query_id || "database_validation",
+                query_id: toolInput.query_id || "",
+                status: "failed",
+                passed: false,
+                error: e.message
+              }],
+              executed_at: (/* @__PURE__ */ new Date()).toISOString()
+            };
+            if (this.testInfo) {
+              await this.testInfo.attach("database_validation_report", {
+                body: Buffer.from(JSON.stringify(report, null, 2), "utf-8"),
+                contentType: "application/json"
+              });
+            }
+            toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Database validation error: ${e.message}` });
+          }
+        } else if (toolName === "preview_db_validation") {
+          console.log(`>>ARCALITY_STATUS>> [DB] Preview de validacion PostgreSQL: ${toolInput.query_id}...`);
+          try {
+            const preview = await previewDatabaseValidation(toolInput);
+            if (this.testInfo) {
+              await this.testInfo.attach("database_validation_preview", {
+                body: Buffer.from(JSON.stringify(preview, null, 2), "utf-8"),
+                contentType: "application/json"
+              });
+            }
+            toolResults.push({
+              type: "tool_result",
+              tool_use_id: toolUse.id,
+              content: `Database validation preview ready: ${preview.name}
+${JSON.stringify(preview, null, 2)}`
+            });
+          } catch (e) {
+            toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Database validation preview error: ${e.message}` });
+          }
+        } else if (toolName === "register_db_profile") {
+          console.log(`>>ARCALITY_STATUS>> [DB] Registrando o validando perfil local: ${toolInput.profile || process.env.ARCALITY_DB_PROFILE || "qa_local"}...`);
+          try {
+            const profileReport = registerDatabaseProfile(toolInput);
+            if (this.testInfo) {
+              await this.testInfo.attach("database_profile_registration", {
+                body: Buffer.from(JSON.stringify(profileReport, null, 2), "utf-8"),
+                contentType: "application/json"
+              });
+            }
+            toolResults.push({
+              type: "tool_result",
+              tool_use_id: toolUse.id,
+              content: `Database profile ready: ${profileReport.profile}
+${JSON.stringify(profileReport, null, 2)}`
+            });
+          } catch (e) {
+            toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Database profile error: ${e.message}` });
+          }
+        } else if (toolName === "summarize_execution_evidence") {
+          try {
+            const attachments = Array.isArray(this.testInfo?.attachments) ? this.testInfo.attachments.map((att) => ({
+              name: att.name,
+              contentType: att.contentType,
+              path: att.path
+            })) : [];
+            const evidenceSummary = summarizeExecutionEvidence(toolInput, {
+              logs: this.logs,
+              attachments,
+              current_url: this.page.url()
+            });
+            if (this.testInfo) {
+              await this.testInfo.attach("execution_evidence_summary", {
+                body: Buffer.from(JSON.stringify(evidenceSummary, null, 2), "utf-8"),
+                contentType: "application/json"
+              });
+            }
+            toolResults.push({
+              type: "tool_result",
+              tool_use_id: toolUse.id,
+              content: `Execution evidence summary ready: ${evidenceSummary.final_status}
+${JSON.stringify(evidenceSummary, null, 2)}`
+            });
+          } catch (e) {
+            toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Execution evidence summary error: ${e.message}` });
+          }
         } else if (toolName === "capture_console_errors") {
           const logs = this.logs.length > 0 ? this.logs.join("\n") : "No console errors/warnings/network errors captured.";
           toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: logs });
@@ -3551,7 +4628,7 @@ ${history.slice(-25).join("\n") || "None"}`
           }
         } else if (toolName === "measure_page_performance") {
           const { thresholds = {} } = toolInput;
-          console.log(`>>ARCALITY_STATUS>> \u26A1 Midiendo rendimiento de p\xE1gina...`);
+          console.log(`>>ARCALITY_STATUS>> ? Midiendo rendimiento de p\uFFFDgina...`);
           try {
             const perfData = await this.page.evaluate(() => {
               const nav = performance.getEntriesByType("navigation")[0];
@@ -3567,7 +4644,7 @@ ${history.slice(-25).join("\n") || "None"}`
               };
             });
             const results = [
-              `\u{1F4CA} PERFORMANCE METRICS:`,
+              `?? PERFORMANCE METRICS:`,
               `  Load Time: ${perfData.load_time_ms ?? "N/A"}ms`,
               `  DOM Content Loaded: ${perfData.dom_content_loaded_ms ?? "N/A"}ms`,
               `  First Contentful Paint: ${perfData.first_contentful_paint_ms ?? "N/A"}ms`,
@@ -3580,7 +4657,7 @@ ${history.slice(-25).join("\n") || "None"}`
           }
         } else if (toolName === "save_navigation_checkpoint") {
           const { checkpoint_name, include_storage = true } = toolInput;
-          console.log(`>>ARCALITY_STATUS>> \u{1F4BE} Guardando punto de control: "${checkpoint_name}"...`);
+          console.log(`>>ARCALITY_STATUS>> ?? Guardando punto de control: "${checkpoint_name}"...`);
           try {
             const url = this.page.url();
             const context = this.page.context();
@@ -3607,17 +4684,17 @@ ${history.slice(-25).join("\n") || "None"}`
               sessionStorage = storageData.sessionStorage;
             }
             this.checkpoints.set(checkpoint_name, { url, storageState, localStorage, sessionStorage });
-            const result = `\u2705 Checkpoint "${checkpoint_name}" saved successfully.`;
+            const result = `? Checkpoint "${checkpoint_name}" saved successfully.`;
             toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: result });
           } catch (e) {
             toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Error saving checkpoint: ${e.message}` });
           }
         } else if (toolName === "restore_navigation_checkpoint") {
           const { checkpoint_name } = toolInput;
-          console.log(`>>ARCALITY_STATUS>> \u{1F504} Restaurando punto de control: "${checkpoint_name}"...`);
+          console.log(`>>ARCALITY_STATUS>> ?? Restaurando punto de control: "${checkpoint_name}"...`);
           const checkpoint = this.checkpoints.get(checkpoint_name);
           if (!checkpoint) {
-            toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `\u274C Checkpoint "${checkpoint_name}" not found.` });
+            toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `? Checkpoint "${checkpoint_name}" not found.` });
           } else {
             try {
               const context = this.page.context();
@@ -3635,7 +4712,7 @@ ${history.slice(-25).join("\n") || "None"}`
                   window.sessionStorage.setItem(k, v);
               }, { ls: checkpoint.localStorage, ss: checkpoint.sessionStorage });
               await this.page.reload({ waitUntil: "domcontentloaded", timeout: 15e3 });
-              toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `\u2705 Checkpoint "${checkpoint_name}" restored.` });
+              toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `? Checkpoint "${checkpoint_name}" restored.` });
             } catch (e) {
               toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Error restoring checkpoint: ${e.message}` });
             }
@@ -3646,7 +4723,7 @@ ${history.slice(-25).join("\n") || "None"}`
           if (!el) {
             toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Element idx ${idx} not found.` });
           } else {
-            console.log(`>>ARCALITY_STATUS>> \u{1F6E1}\uFE0F [Security] Probando inyecci\xF3n XSS en IDX ${idx}...`);
+            console.log(`>>ARCALITY_STATUS>> ??? [Security] Probando inyecci\uFFFDn XSS en IDX ${idx}...`);
             let payload = "<script>alert(1)</script>";
             if (payload_type === "image")
               payload = "<img src=x onerror=alert(1)>";
@@ -3656,7 +4733,7 @@ ${history.slice(-25).join("\n") || "None"}`
               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.` });
+              toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Payload inyectado. Aseg\uFFFDrate de probar si el payload fue ejecutado revisando el DOM, o realiza el sumbit y observa si el input regres\uFFFD renderizado tal cual o sanitizado.` });
               if (this.testInfo)
                 this.testInfo.attach("security_tool_call", { body: JSON.stringify({ action: "test_xss_injection", target: idx, payload }), contentType: "application/json" });
             } catch (e) {
@@ -3665,7 +4742,7 @@ ${history.slice(-25).join("\n") || "None"}`
           }
         } else if (toolName === "test_auth_bypass") {
           const { target_url } = toolInput;
-          console.log(`>>ARCALITY_STATUS>> \u{1F6E1}\uFE0F [Security] Intentando Auth Bypass en ${target_url}...`);
+          console.log(`>>ARCALITY_STATUS>> ??? [Security] Intentando Auth Bypass en ${target_url}...`);
           try {
             const baseUrl = new URL(this.page.url()).origin;
             const fullUrl = new URL(target_url, baseUrl).toString();
@@ -3677,15 +4754,15 @@ ${history.slice(-25).join("\n") || "None"}`
 URL resultante: ${resultingUrl}. 
 `;
             if (resultingUrl !== fullUrl)
-              resultData += `Posiblemente redirigido (el bypass fall\xF3 o te enviaron a Login).`;
+              resultData += `Posiblemente redirigido (el bypass fall\uFFFD o te enviaron a Login).`;
             else
-              resultData += `URL se mantuvo igual. \xA1Esto podr\xEDa ser un IDOR o Auth Bypass si ves datos a los que no deber\xEDas acceder!`;
+              resultData += `URL se mantuvo igual. \uFFFDEsto podr\uFFFDa ser un IDOR o Auth Bypass si ves datos a los que no deber\uFFFDas acceder!`;
             toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: resultData });
           } catch (e) {
             toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Error test_auth_bypass: ${e.message}` });
           }
         } else if (toolName === "scan_sensitive_data_exposure") {
-          console.log(`>>ARCALITY_STATUS>> \u{1F6E1}\uFE0F [Security] Escaneando datos sensibles...`);
+          console.log(`>>ARCALITY_STATUS>> ??? [Security] Escaneando datos sensibles...`);
           try {
             const issues = await scan_sensitive_data_exposure(this.page);
             if (issues.length > 0) {
@@ -3700,7 +4777,7 @@ ${report}` });
             toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Error scan_sensitive_data_exposure: ${e.message}` });
           }
         } else if (toolName === "audit_http_headers") {
-          console.log(`>>ARCALITY_STATUS>> \u{1F6E1}\uFE0F [Security] Auditando headers HTTP...`);
+          console.log(`>>ARCALITY_STATUS>> ??? [Security] Auditando headers HTTP...`);
           try {
             const issues = await audit_http_headers(this.page);
             if (issues.length > 0) {
@@ -3708,14 +4785,14 @@ ${report}` });
               toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Vulnerabilidades de Headers detectadas:
 ${report}` });
             } else {
-              toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: "No se detectaron problemas en los headers de seguridad b\xE1sicos." });
+              toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: "No se detectaron problemas en los headers de seguridad b\uFFFDsicos." });
             }
           } catch (e) {
             toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Error audit_http_headers: ${e.message}` });
           }
         } else if (toolName === "create_test_evidence") {
           const { evidence_type, annotations, save_as, description, finish_run = false } = toolInput;
-          console.log(`\u{1F4F8} [SKILL] Creating test evidence: "${save_as}"...`);
+          console.log(`?? [SKILL] Creating test evidence: "${save_as}"...`);
           try {
             const filename = save_as.replace(/[^a-zA-Z0-9_-]/g, "_");
             if (annotations && annotations.length > 0) {
@@ -3764,20 +4841,20 @@ ${report}` });
                   contentType: "text/plain"
                 });
               }
-              toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `\u2705 Evidence "${filename}" created and attached.` });
+              toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `? Evidence "${filename}" created and attached.` });
               if (finish_run) {
                 this.lastScreenshot = base64Img;
                 return { thought: `Evidence "${description || filename}" created. Mission complete.`, actions: [], finish: true };
               }
             } else {
-              toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `\u26A0\uFE0F testInfo not available.` });
+              toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `?? testInfo not available.` });
             }
           } catch (e) {
             toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Error creating evidence: ${e.message}` });
           }
         } else if (toolName === "send_keyboard_event") {
           const { key, idx, repeat = 1 } = toolInput;
-          console.log(`>>ARCALITY_STATUS>> \u2328\uFE0F Enviando tecla: "${key}" ${idx !== void 0 ? `(focus en IDX:${idx})` : "(focus actual)"} x${repeat}`);
+          console.log(`>>ARCALITY_STATUS>> ?? Enviando tecla: "${key}" ${idx !== void 0 ? `(focus en IDX:${idx})` : "(focus actual)"} x${repeat}`);
           try {
             if (idx !== void 0) {
               const c = state.components.find((comp) => comp.idx === idx);
@@ -3793,13 +4870,13 @@ ${report}` });
               if (repeat > 1)
                 await this.page.waitForTimeout(100);
             }
-            toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `\u2705 Key "${key}" pressed ${repeat} time(s).` });
+            toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `? Key "${key}" pressed ${repeat} time(s).` });
           } 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}"`);
+          console.log(`>>ARCALITY_STATUS>> ???? Type sequentially IDX:${idx} ? "${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." });
@@ -3830,7 +4907,7 @@ ${report}` });
               toolResults.push({
                 type: "tool_result",
                 tool_use_id: toolUse.id,
-                content: `\u2705 Sequential typing completed. Current value: "${finalValue}".`
+                content: `? Sequential typing completed. Current value: "${finalValue}".`
               });
             } catch (e) {
               toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Error typing sequentially: ${e.message}` });
@@ -3839,7 +4916,7 @@ ${report}` });
         } else if (toolName === "interact_native_control") {
           const { idx, control_type, value } = toolInput;
           const c = state.components.find((comp) => comp.idx === idx);
-          console.log(`>>ARCALITY_STATUS>> \u{1F39B}\uFE0F Control nativo: ${control_type} IDX:${idx} \u2192 "${value}"`);
+          console.log(`>>ARCALITY_STATUS>> ??? Control nativo: ${control_type} IDX:${idx} ? "${value}"`);
           if (!c) {
             toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: "Element not found." });
           } else {
@@ -3854,7 +4931,7 @@ ${report}` });
                     await loc.fill(value, { timeout: 3e3 });
                     const actualValue = await loc.inputValue();
                     if (actualValue && actualValue !== "") {
-                      toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `\u2705 ${control_type} set to "${actualValue}" via fill().` });
+                      toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `? ${control_type} set to "${actualValue}" via fill().` });
                       break;
                     }
                   } catch {
@@ -3865,12 +4942,12 @@ ${report}` });
                   const digits = value.replace(/[:-T]/g, "");
                   await this.page.keyboard.type(digits, { delay: 50 });
                   const finalValue = await loc.inputValue().catch(() => "");
-                  toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `\u2705 ${control_type} set via keyboard. Current value: "${finalValue}".` });
+                  toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `? ${control_type} set via keyboard. Current value: "${finalValue}".` });
                   break;
                 }
                 case "color":
                   await loc.fill(value, { timeout: 3e3 });
-                  toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `\u2705 Color set to "${value}".` });
+                  toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `? Color set to "${value}".` });
                   break;
                 case "range": {
                   const numVal = parseFloat(value);
@@ -3884,7 +4961,7 @@ ${report}` });
                       }
                     }, { sel: c.selector, val: String(numVal) });
                   });
-                  toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `\u2705 Range set to ${numVal}.` });
+                  toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `? Range set to ${numVal}.` });
                   break;
                 }
                 case "select": {
@@ -3898,17 +4975,17 @@ ${report}` });
                     }
                   }
                   const selected = await loc.inputValue().catch(() => "unknown");
-                  toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `\u2705 Option selected. Value: "${selected}".` });
+                  toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `? Option selected. Value: "${selected}".` });
                   break;
                 }
                 case "contenteditable":
                   await loc.click({ force: true });
                   await this.page.keyboard.press("Control+a");
                   await this.page.keyboard.type(value, { delay: 30 });
-                  toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `\u2705 Content set to "${value}".` });
+                  toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `? Content set to "${value}".` });
                   break;
                 default:
-                  toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `\u274C Unknown control type: ${control_type}` });
+                  toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `? Unknown control type: ${control_type}` });
               }
             } catch (e) {
               toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Error interacting with native control: ${e.message}` });
@@ -3916,7 +4993,7 @@ ${report}` });
           }
         } else if (toolName === "scroll_page") {
           const { direction, amount = 500, idx } = toolInput;
-          console.log(`>>ARCALITY_STATUS>> \u{1F4DC} Scroll: ${direction} ${amount}px ${idx !== void 0 ? `(container IDX:${idx})` : "(page)"}`);
+          console.log(`>>ARCALITY_STATUS>> ?? Scroll: ${direction} ${amount}px ${idx !== void 0 ? `(container IDX:${idx})` : "(page)"}`);
           try {
             if (idx !== void 0) {
               const c = state.components.find((comp) => comp.idx === idx);
@@ -3962,7 +5039,7 @@ ${report}` });
               }
             }
             await this.page.waitForTimeout(300);
-            toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `\u2705 Scrolled ${direction} ${direction === "top" || direction === "bottom" ? "completely" : `${amount}px`}. Page state will refresh on next turn.` });
+            toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `? Scrolled ${direction} ${direction === "top" || direction === "bottom" ? "completely" : `${amount}px`}. Page state will refresh on next turn.` });
           } catch (e) {
             toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Error scrolling: ${e.message}` });
           }
@@ -4001,7 +5078,7 @@ ${report}` });
     return { thought: "Max internal turns reached", actions: [] };
   }
   /**
-   * QA Skill: Genera una explicación "humana" y amigable de por qué la misión fue exitosa.
+   * QA Skill: Genera una explicaci�n "humana" y amigable de por qu� la misi�n fue exitosa.
    */
   async humanizeMissionResult(prompt, history) {
     if (!process.env.ANTHROPIC_API_KEY)
@@ -4027,9 +5104,9 @@ ${report}` });
         body: JSON.stringify({
           model: process.env.CLAUDE_MODEL || "claude-4-5-sonnet-latest",
           max_tokens: 300,
-          system: "Eres un Senior QA personalizador de reportes. Tu tarea es resumir en una sola frase corta, profesional y amigable por qu\xE9 una misi\xF3n de testing fue exitosa bas\xE1ndote en el historial de pasos. Usa un tono de victoria. No menciones detalles t\xE9cnicos como 'selectores' o 'DOM'. El resumen debe empezar con algo como '\xA1Misi\xF3n cumplida! ...'",
+          system: "Eres un Senior QA personalizador de reportes. Tu tarea es resumir en una sola frase corta, profesional y amigable por qu\uFFFD una misi\uFFFDn de testing fue exitosa bas\uFFFDndote en el historial de pasos. Usa un tono de victoria. No menciones detalles t\uFFFDcnicos como 'selectores' o 'DOM'. El resumen debe empezar con algo como '\uFFFDMisi\uFFFDn cumplida! ...'",
           messages: [
-            { role: "user", content: `Misi\xF3n original: ${prompt}
+            { role: "user", content: `Misi\uFFFDn original: ${prompt}
 
 history of steps:
 ${history.join("\n")}` }
@@ -4218,8 +5295,8 @@ var SecurityScanner = class {
 
 // tests/_helpers/agentic-runner.spec.ts
 var import_config = require("dotenv/config");
-var fs6 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
+var fs7 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
 var crypto2 = __toESM(require("crypto"));
 init_asset_resolver();
 var _sessionRuleCache = /* @__PURE__ */ new Set();
@@ -4282,24 +5359,31 @@ function resolveTargetUrl(baseUrl, currentUrl, targetPath) {
   const parsedBase = new URL(baseUrl || referenceUrl);
   const parsedReference = new URL(referenceUrl);
   const normalizedTarget = targetPath.trim();
+  const basePath = parsedBase.pathname.replace(/\/+$/, "");
+  if (normalizedTarget.startsWith("?") || normalizedTarget.startsWith("#")) {
+    return new URL(normalizedTarget, parsedReference).toString();
+  }
   if (normalizedTarget.startsWith("/")) {
-    const basePath = parsedBase.pathname.replace(/\/+$/, "");
     const targetAlreadyIncludesBase = basePath && (normalizedTarget === basePath || normalizedTarget.startsWith(`${basePath}/`));
     const combinedPath = targetAlreadyIncludesBase ? normalizedTarget : `${basePath}${normalizedTarget}`.replace(/\/{2,}/g, "/");
     return new URL(`${parsedBase.origin}${combinedPath}`).toString();
   }
-  return new URL(normalizedTarget, parsedReference).toString();
+  if (normalizedTarget.startsWith("./") || normalizedTarget.startsWith("../")) {
+    return new URL(normalizedTarget, parsedReference).toString();
+  }
+  const childPath = `${basePath}/${normalizedTarget}`.replace(/\/{2,}/g, "/");
+  return new URL(`${parsedBase.origin}${childPath}`).toString();
 }
 function writeBatchMissionResult(payload) {
   const runDomainDir = process.env.ARCALITY_RUN_DOMAIN_DIR;
   if (!runDomainDir)
     return;
   try {
-    if (!fs6.existsSync(runDomainDir)) {
-      fs6.mkdirSync(runDomainDir, { recursive: true });
+    if (!fs7.existsSync(runDomainDir)) {
+      fs7.mkdirSync(runDomainDir, { recursive: true });
     }
-    fs6.writeFileSync(
-      path6.join(runDomainDir, "mission-result.json"),
+    fs7.writeFileSync(
+      path8.join(runDomainDir, "mission-result.json"),
       JSON.stringify(payload, null, 2)
     );
   } catch {
@@ -4328,10 +5412,10 @@ function writeBatchMissionResult(payload) {
   } 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)) {
+  const memoryFile = path8.join(contextDir, "memoria-arcality.json");
+  if (fs7.existsSync(memoryFile)) {
     try {
-      fs6.unlinkSync(memoryFile);
+      fs7.unlinkSync(memoryFile);
     } catch {
     }
   }
@@ -4386,33 +5470,64 @@ function writeBatchMissionResult(payload) {
   let accumulatedCost = 0;
   let totalMissionUsage = { input_tokens: 0, output_tokens: 0, cache_creation_input_tokens: 0, cache_read_input_tokens: 0 };
   let bugClassification = "";
+  let databaseValidationReport = null;
   const missionSummaryPaths = /* @__PURE__ */ new Set();
-  const updateSavedMissionClassification = () => {
-    if (!bugClassification)
-      return;
+  const updateSavedMissionSummaries = () => {
     for (const summaryPath of missionSummaryPaths) {
       try {
-        if (!fs6.existsSync(summaryPath))
+        if (!fs7.existsSync(summaryPath))
           continue;
-        const data = JSON.parse(fs6.readFileSync(summaryPath, "utf8"));
-        data.bug_classification = bugClassification;
-        fs6.writeFileSync(summaryPath, JSON.stringify(data, null, 2));
+        const data = JSON.parse(fs7.readFileSync(summaryPath, "utf8"));
+        data.success = aiMarkedSuccess && !hasCriticalError;
+        data.error = hasCriticalError;
+        data.fail_reason = failReason;
+        data.fail_reasoning = failReasoning;
+        if (bugClassification)
+          data.bug_classification = bugClassification;
+        if (databaseValidationReport)
+          data.database_validation = databaseValidationReport;
+        fs7.writeFileSync(summaryPath, JSON.stringify(data, null, 2));
       } catch {
       }
     }
   };
+  const updateSavedMissionClassification = updateSavedMissionSummaries;
+  const runPostMissionDatabaseValidations = async () => {
+    if (!aiMarkedSuccess || hasCriticalError || databaseValidationReport)
+      return;
+    const rawValidations = process.env.ARCALITY_DB_VALIDATIONS_JSON || process.env.ARCALITY_DB_VALIDATIONS || "";
+    if (!rawValidations.trim())
+      return;
+    console.log(`>>ARCALITY_STATUS>> [DB] Ejecutando corroboracion post-mision...`);
+    databaseValidationReport = await runDatabaseValidationsFromEnv();
+    if (!databaseValidationReport)
+      return;
+    await testInfo.attach("database_validation_report", {
+      body: Buffer.from(JSON.stringify(databaseValidationReport, null, 2), "utf-8"),
+      contentType: "application/json"
+    });
+    const summary = databaseValidationReport.summary || { total: 0, passed: 0, failed: 0 };
+    history.push(`Turno ${stepCount}: [DB_VALIDATION] ${summary.passed}/${summary.total} validaciones BD exitosas.`);
+    if (!databaseValidationReport.passed) {
+      aiMarkedSuccess = false;
+      hasCriticalError = true;
+      failReason = "database_validation_failed";
+      failReasoning = `La UI parecia exitosa, pero la corroboracion en PostgreSQL fallo (${summary.failed}/${summary.total} validaciones fallidas). Revisa la seccion Validacion BD del reporte.`;
+    }
+    updateSavedMissionSummaries();
+  };
   const saveMissionResults = () => {
     if (resultsSaved)
       return;
     resultsSaved = true;
-    if (!fs6.existsSync(contextDir))
-      fs6.mkdirSync(contextDir, { recursive: true });
+    if (!fs7.existsSync(contextDir))
+      fs7.mkdirSync(contextDir, { recursive: true });
     const finalSuccess = aiMarkedSuccess && !hasCriticalError;
     try {
-      const memoryFile2 = path6.join(contextDir, "memoria-arcality.json");
+      const memoryFile2 = path8.join(contextDir, "memoria-arcality.json");
       let memories = [];
-      if (fs6.existsSync(memoryFile2)) {
-        const content = fs6.readFileSync(memoryFile2, "utf8").trim();
+      if (fs7.existsSync(memoryFile2)) {
+        const content = fs7.readFileSync(memoryFile2, "utf8").trim();
         if (content) {
           try {
             memories = JSON.parse(content);
@@ -4484,10 +5599,11 @@ function writeBatchMissionResult(payload) {
         fail_reason: failReason,
         fail_reasoning: failReasoning,
         bug_classification: bugClassification || null,
-        timestamp: Date.now()
+        timestamp: Date.now(),
+        database_validation: databaseValidationReport
       };
       memories.push(missionData);
-      fs6.writeFileSync(memoryFile2, JSON.stringify(memories, null, 2));
+      fs7.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) {
@@ -4509,23 +5625,24 @@ function writeBatchMissionResult(payload) {
         target: process.env.BASE_URL || "",
         target_path: process.env.TARGET_PATH || "",
         report_dir: process.env.REPORTS_DIR || "",
-        timestamp: timestampIso
+        timestamp: timestampIso,
+        database_validation: databaseValidationReport
       };
-      const logPath = path6.join(contextDir, `agent-log-${timestampMs}.json`);
-      fs6.writeFileSync(logPath, JSON.stringify(summaryPayload, null, 2));
+      const logPath = path8.join(contextDir, `agent-log-${timestampMs}.json`);
+      fs7.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));
+      const durableLogsDir = path8.join(runDomainDir, "logs");
+      fs7.mkdirSync(durableLogsDir, { recursive: true });
+      const durableLogPath = path8.join(durableLogsDir, `mission-log-${timestampMs}.json`);
+      fs7.writeFileSync(durableLogPath, JSON.stringify(summaryPayload, null, 2));
       missionSummaryPaths.add(durableLogPath);
       writeBatchMissionResult(summaryPayload);
       if (runDomainDir) {
-        missionSummaryPaths.add(path6.join(runDomainDir, "mission-result.json"));
+        missionSummaryPaths.add(path8.join(runDomainDir, "mission-result.json"));
       }
       try {
         const historyLine = JSON.stringify({
@@ -4536,12 +5653,12 @@ function writeBatchMissionResult(payload) {
           fail_reason: failReason,
           report_dir: process.env.REPORTS_DIR || ""
         }) + "\n";
-        fs6.appendFileSync(
-          path6.join(contextDir, "arcality-history.log"),
+        fs7.appendFileSync(
+          path8.join(contextDir, "arcality-history.log"),
           historyLine
         );
-        fs6.appendFileSync(
-          path6.join(durableLogsDir, "arcality-history.log"),
+        fs7.appendFileSync(
+          path8.join(durableLogsDir, "arcality-history.log"),
           historyLine
         );
       } catch (e) {
@@ -4739,11 +5856,11 @@ function writeBatchMissionResult(payload) {
           timestamp: Date.now()
         };
         try {
-          const memoryFile2 = path6.join(contextDir, "memoria-agente.json");
+          const memoryFile2 = path8.join(contextDir, "memoria-agente.json");
           let memories = [];
-          if (fs6.existsSync(memoryFile2)) {
+          if (fs7.existsSync(memoryFile2)) {
             try {
-              memories = JSON.parse(fs6.readFileSync(memoryFile2, "utf8"));
+              memories = JSON.parse(fs7.readFileSync(memoryFile2, "utf8"));
             } catch {
               memories = [];
             }
@@ -4755,14 +5872,14 @@ function writeBatchMissionResult(payload) {
           if (existingIdx < 0) {
             if (resolvedStepsData.length > 0) {
               memories.push(localMemoryData);
-              fs6.writeFileSync(memoryFile2, JSON.stringify(memories, null, 2));
+              fs7.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;
-            fs6.writeFileSync(memoryFile2, JSON.stringify(memories, null, 2));
+            fs7.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.`);
@@ -5144,7 +6261,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 = path6.join(contextDir, `portal-blank-state-${Date.now()}.png`);
+        const blankEvidencePath = path8.join(contextDir, `portal-blank-state-${Date.now()}.png`);
         await page.screenshot({ path: blankEvidencePath, fullPage: true }).catch(() => {
         });
         const blankUrl = page.url();
@@ -5421,7 +6538,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 = path6.join(contextDir, `portal-blank-dashboard-${Date.now()}.png`);
+                    const blankEvidencePath = path8.join(contextDir, `portal-blank-dashboard-${Date.now()}.png`);
                     await page.screenshot({ path: blankEvidencePath, fullPage: true }).catch(() => {
                     });
                     console.error(`
@@ -5643,6 +6760,7 @@ Acci\xF3n bloqueada: Bucle de tipo ${loopType} sobre los elementos ${Array.from(
       }
     }
   }
+  await runPostMissionDatabaseValidations();
   if (aiMarkedSuccess) {
     hasCriticalError = false;
     await persistCollectiveMemory();
@@ -5705,8 +6823,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 = path6.join(contextDir, "last-mission-smart.yaml");
-      fs6.writeFileSync(yamlPath, smartYaml);
+      const yamlPath = path8.join(contextDir, "last-mission-smart.yaml");
+      fs7.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"),
@@ -5808,15 +6926,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 (fs6.existsSync(contextDir)) {
+  if (fs7.existsSync(contextDir)) {
     try {
-      const files = fs6.readdirSync(contextDir);
+      const files = fs7.readdirSync(contextDir);
       for (const file of files) {
         if (file.endsWith(".json") || file.endsWith(".png")) {
-          fs6.unlinkSync(path6.join(contextDir, file));
+          fs7.unlinkSync(path8.join(contextDir, file));
         }
       }
-      fs6.rmSync(contextDir, { recursive: true, force: true });
+      fs7.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}`);