@arcadialdev/arcality 2.4.36 → 2.4.48

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcadialdev/arcality",
-  "version": "2.4.36",
-  "description": "AI-powered QA testing tool — Autonomous web testing agent by Arcadial",
+  "version": "2.4.48",
+  "description": "El primer ingeniero QA Autónomo integrado al CI/CD. Creado por Arcadial.",
   "main": "index.js",
   "scripts": {
     "dev": "node scripts/gen-and-run.mjs",
@@ -54,6 +54,7 @@
     "esbuild": "^0.20.2"
   },
   "dependencies": {
+    "@azure/storage-blob": "^12.31.0",
     "@clack/prompts": "^1.0.1",
     "@inquirer/prompts": "^8.2.0",
     "@playwright/test": "^1.57.0",
@@ -62,9 +63,10 @@
     "dotenv": "^17.2.3",
     "figlet": "^1.9.4",
     "js-yaml": "^4.1.1",
+    "mime-types": "^3.0.2",
     "node-fetch": "^3.3.2",
     "prompts": "^2.4.2",
     "terminal-image": "^1.1.0",
     "tsx": "^4.21.0"
   }
-}
+}

package/scripts/gen-and-run.mjs

@@ -620,6 +620,14 @@ async function main() {
             const { validateApiKey, startMission: requestMission } = await import('../src/arcalityClient.mjs');
 
             const validation = await validateApiKey();
+            if (process.env.DEBUG || process.argv.includes('--debug')) {
+                console.log(chalk.gray(`[DEBUG] Validation result: ${JSON.stringify(validation, null, 2)}`));
+            }
+            
+            const detectedOrgId = validation.organization_id || validation.organizationId || validation.OrganizationId;
+            if (detectedOrgId) {
+                process.env.ARCALITY_ORG_ID = detectedOrgId;
+            }
             if (!validation.valid) {
                 const errorMessages = {
                     'no_api_key': '🔑 API Key not found.\n   Configure it via `arcality init` or in .env (ARCALITY_API_KEY)',
@@ -636,7 +644,7 @@ async function main() {
 
             // Show plan info
             const modeLabel = validation.mode === 'mock' ? chalk.gray('(local)') : chalk.green('(live)');
-            const dailyLimitDisplay = validation.daily_limit === -1 ? '∞' : (validation.daily_limit || 50);
+            const dailyLimitDisplay = validation.daily_limit === -1 ? '∞' : (validation.daily_limit || 35);
             const remainingDisplay = validation.remaining >= 999999 ? '∞' : validation.remaining;
             note(
                 chalk.bold.white('✅ Valid API Key ') + modeLabel + '\n' +
@@ -653,9 +661,13 @@ async function main() {
             if (!selectedProjectId) {
                 // If no project ID from config, try to create/select from backend
                 try {
+                    const projController = new AbortController();
+                    const projTimeout = setTimeout(() => projController.abort(), 5000);
                     const projRes = await fetch(`${apiBase}/api/v1/projects`, {
-                        headers: { 'x-api-key': process.env.ARCALITY_API_KEY || '' }
+                        headers: { 'x-api-key': process.env.ARCALITY_API_KEY || '' },
+                        signal: projController.signal
                     });
+                    clearTimeout(projTimeout);
 
                     if (projRes.ok) {
                         const data = await projRes.json();
@@ -745,7 +757,8 @@ async function main() {
                 ...process.env,
                 ARCALITY_API_URL: getApiUrl(),          // Internal URL — always injected explicitly
                 ARCALITY_PROJECT_ID: finalProjectId,
-                ARCALITY_MISSION_ID: mission.mission_id || '',  // ← Propagate mission_id to every proxy call
+                ARCALITY_MISSION_ID: mission.mission_id || mission.missionId || mission.MissionId || '',  // ← Propagate mission_id to every proxy call
+                ARCALITY_ORG_ID: validation.organization_id || validation.organizationId || validation.OrganizationId || process.env.ARCALITY_ORG_ID || '',  // ← Propagate org_id for pattern persistence
                 BASE_URL: projectConfig?.project?.baseUrl || dotEnv.BASE_URL || process.env.BASE_URL || fallbackBaseUrl || 'http://localhost:3000',
                 LOGIN_USER: projectConfig?.auth?.username || dotEnv.LOGIN_USER || process.env.LOGIN_USER,
                 LOGIN_PASSWORD: projectConfig?.auth?.password || dotEnv.LOGIN_PASSWORD || process.env.LOGIN_PASSWORD,
@@ -758,7 +771,8 @@ async function main() {
             };
 
             if (finalProjectId) {
-                console.log(chalk.gray(`\n>> ARCALITY_PROJECT_ID: ${finalProjectId}`));
+                console.log(chalk.gray(`>> ARCALITY_PROJECT_ID: ${finalProjectId}`));
+                console.log(chalk.gray(`>> ARCALITY_ORG_ID: ${mergedEnv.ARCALITY_ORG_ID || 'NONE'}`));
             }
 
             // ── Resolve execution paths ──
@@ -805,9 +819,6 @@ async function main() {
                 if (!process.argv.includes('--debug')) s.stop(chalk.green('✅ Mission completed successfully.'));
                 else console.log(chalk.green('✅ Mission completed successfully.'));
 
-                // ── End Mission ──
-                const { endMission } = await import('../src/arcalityClient.mjs');
-                
                 let finalUsage = undefined;
                 try {
                     const ctxDir = process.env.CONTEXT_DIR;
@@ -822,6 +833,27 @@ async function main() {
                     }
                 } catch(e) {}
 
+                // ── Upload Evidence ──
+                const { endMission, getEvidenceSasToken } = await import('../src/arcalityClient.mjs');
+                const { uploadEvidence } = await import('../src/EvidenceUploader.mjs');
+
+                try {
+                    const sasData = await getEvidenceSasToken(mission.mission_id, finalProjectId);
+                    if (sasData && sasData.sasUrl) {
+                        if (!process.argv.includes('--debug')) s.start('☁️  Uploading evidence to Azure...');
+                        const reportsDir = process.env.REPORTS_DIR || path.join(ORIGINAL_CWD, 'tests-report');
+                        
+                        await run("node", [path.join(PROJECT_ROOT, "scripts/rebrand-report.mjs")]).catch(() => { });
+                        
+                        await uploadEvidence(reportsDir, sasData.sasUrl, sasData.basePath);
+                        if (!process.argv.includes('--debug')) s.stop(chalk.green('✅ Evidence uploaded successfully.'));
+                    }
+                } catch (e) {
+                    if (process.argv.includes('--debug')) console.log(chalk.yellow(`⚠️  Could not upload evidence: ${e.message}`));
+                    if (!process.argv.includes('--debug')) s.stop(chalk.yellow('⚠️  Evidence upload failed.'));
+                }
+
+                // ── End Mission ──
                 await endMission(mission.mission_id, 'success', finalUsage);
 
                 // ── Ping Project ──
@@ -881,8 +913,8 @@ async function main() {
 
                 // End mission with failure
                 try {
-                    const { endMission } = await import('../src/arcalityClient.mjs');
                     let finalUsage = undefined;
+                    let failReason = "timeout_or_crash";
                     try {
                         const ctxDir = process.env.CONTEXT_DIR;
                         if (fs.existsSync(ctxDir)) {
@@ -892,10 +924,29 @@ async function main() {
                                 const lastLog = path.join(ctxDir, logFiles[logFiles.length - 1]);
                                 const logData = JSON.parse(fs.readFileSync(lastLog, 'utf8'));
                                 finalUsage = logData.usage;
+                                failReason = logData.fail_reason || failReason;
                             }
                         }
                     } catch(e) {}
-                    await endMission(mission.mission_id, 'failed', finalUsage);
+
+                    // ── Upload Evidence ──
+                    const { endMission, getEvidenceSasToken } = await import('../src/arcalityClient.mjs');
+                    const { uploadEvidence } = await import('../src/EvidenceUploader.mjs');
+
+                    try {
+                        const sasData = await getEvidenceSasToken(mission.mission_id, finalProjectId);
+                        if (sasData && sasData.sasUrl) {
+                            if (!process.argv.includes('--debug')) s.start('☁️  Uploading evidence to Azure...');
+                            const reportsDir = process.env.REPORTS_DIR || path.join(ORIGINAL_CWD, 'tests-report');
+                            
+                            await run("node", [path.join(PROJECT_ROOT, "scripts/rebrand-report.mjs")]).catch(() => { });
+                            
+                            await uploadEvidence(reportsDir, sasData.sasUrl, sasData.basePath);
+                            if (!process.argv.includes('--debug')) s.stop(chalk.green('✅ Evidence uploaded successfully.'));
+                        }
+                    } catch (e) {}
+
+                    await endMission(mission.mission_id, 'failed', finalUsage, failReason);
                 } catch { }
             } finally {
                 const sRep = spinner();

package/src/EvidenceUploader.mjs

@@ -0,0 +1,45 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { ContainerClient } from '@azure/storage-blob';
+import mime from 'mime-types';
+
+/**
+ * Subes la evidencia de prueba iterativamente a Azure Blob Storage usando una URL de SAS.
+ * @param {string} reportsDir Directorio local de reportes.
+ * @param {string} sasUrl URL de SAS para el ContainerClient.
+ * @param {string} basePath Path base dentro del contenedor de Azure.
+ */
+export async function uploadEvidence(reportsDir, sasUrl, basePath) {
+    if (!fs.existsSync(reportsDir)) return;
+
+    const containerClient = new ContainerClient(sasUrl);
+
+    async function walkAndUpload(currentDir, relativePath = '') {
+        const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        const uploadPromises = [];
+
+        for (const entry of entries) {
+            const fullPath = path.join(currentDir, entry.name);
+            const entryRelativePath = path.posix.join(relativePath, entry.name);
+
+            if (entry.isDirectory()) {
+                uploadPromises.push(walkAndUpload(fullPath, entryRelativePath));
+            } else {
+                // Blob path en Azure: basePath/ruta_relativa_del_archivo
+                const blobPath = `${basePath}/${entryRelativePath}`;
+                const blockBlobClient = containerClient.getBlockBlobClient(blobPath);
+                
+                const contentType = mime.lookup(entry.name) || 'application/octet-stream';
+
+                uploadPromises.push(
+                    blockBlobClient.uploadFile(fullPath, {
+                        blobHTTPHeaders: { blobContentType: contentType }
+                    })
+                );
+            }
+        }
+        await Promise.all(uploadPromises);
+    }
+
+    await walkAndUpload(reportsDir);
+}

package/src/KnowledgeService.ts

@@ -41,12 +41,14 @@ export class KnowledgeService {
     private apiBase: string;
     private apiKey: string;
     private projectId: string | null = null;
+    private orgId: string | null = null;
 
     private constructor() {
         // API URL is internal-only, loaded from the tool's .env via dotenv
         this.apiBase = process.env.ARCALITY_API_URL || 'https://arcalityqadev.arcadial.lat';
         this.apiKey = process.env.ARCALITY_API_KEY || '';
         this.projectId = process.env.ARCALITY_PROJECT_ID || null;
+        this.orgId = process.env.ARCALITY_ORG_ID || null;
     }
 
     /**
@@ -140,7 +142,7 @@ export class KnowledgeService {
             if (res.status === 200) {
                 const data = await res.json();
                 if (data.status === 'skipped_duplicate_dom') {
-                   // console.log(chalk.gray(`[Knowledge] Ingesta omitida (Duplicado).`));
+                    // console.log(chalk.gray(`[Knowledge] Ingesta omitida (Duplicado).`));
                 } else {
                     console.log(chalk.cyan(`[Knowledge] Ingesta exitosa (Project: ${payload.project_id})`));
                 }
@@ -158,10 +160,13 @@ export class KnowledgeService {
         if (!pid || pid === 'undefined') return null;
         try {
             const pathUrl = new URL(url).pathname;
-            const res = await this.fetchWithTimeout(
-                `${this.apiBase}/api/v1/portal/context?project_id=${pid}&path=${encodeURIComponent(pathUrl)}`,
-                { headers: { 'x-api-key': this.apiKey } }
-            );
+            let contextUrl = `${this.apiBase}/api/v1/portal/context?project_id=${pid}&path=${encodeURIComponent(pathUrl)}`;
+            if (this.orgId) {
+                contextUrl += `&organization_id=${this.orgId}`;
+            }
+            const res = await this.fetchWithTimeout(contextUrl, {
+                headers: { 'x-api-key': this.apiKey }
+            });
             if (!res.ok) return null;
             return await res.json();
         } catch (e: any) {
@@ -185,6 +190,7 @@ export class KnowledgeService {
                     'x-api-key': this.apiKey
                 },
                 body: JSON.stringify({
+                    organization_id: this.orgId,
                     project_id: pid,
                     rule_type: "UI_UX", // Default según especificación
                     title,
@@ -210,6 +216,7 @@ export class KnowledgeService {
                     'x-api-key': this.apiKey
                 },
                 body: JSON.stringify({
+                    organization_id: this.orgId,
                     project_id: pid,
                     field_identifier: identifier,
                     field_type: type,
@@ -235,6 +242,7 @@ export class KnowledgeService {
                     'x-api-key': this.apiKey
                 },
                 body: JSON.stringify({
+                    organization_id: this.orgId,
                     project_id: pid,
                     doc_type: docType,
                     title,

package/src/arcalityClient.mjs

@@ -7,7 +7,7 @@ import path from 'node:path';
 import { getApiKey, getApiUrl, CONFIG_DIR } from './configLoader.mjs';
 
 // ── Backend config (internal, not user-configurable) ──
-const DAILY_MISSION_LIMIT = 50;
+const DAILY_MISSION_LIMIT = 35;
 const USAGE_FILE = path.join(CONFIG_DIR, 'usage.json');
 
 // ═══════════════════════════════════════════════════════
@@ -128,22 +128,31 @@ export async function validateApiKey() {
     // ── LIVE mode: Backend available ──
     if (apiBase) {
         try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 5000);
             const res = await fetch(`${apiBase}/api/v1/auth/validate`, {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
                     'x-api-key': key
-                }
+                },
+                signal: controller.signal
             });
+            clearTimeout(timeout);
 
             if (res.status === 401) return { valid: false, error: 'invalid_api_key', mode: 'live' };
             if (res.status === 403) return { valid: false, error: 'plan_expired', mode: 'live' };
             if (!res.ok) return { valid: false, error: 'server_error', mode: 'live' };
 
             const data = await res.json();
+            if (process.env.DEBUG || process.argv.includes('--debug')) {
+                console.log(`[DEBUG] Auth validation response keys:`, Object.keys(data));
+                console.log(`[DEBUG] Auth validation response:`, JSON.stringify(data, null, 2));
+            }
             return { ...data, valid: true, mode: 'live' };
-        } catch {
-            console.warn('⚠️  Backend not available, using local mode');
+        } catch (e) {
+            const reason = e?.name === 'AbortError' ? 'timeout (5s)' : (e?.message || 'unknown');
+            console.warn(`⚠️  Backend not available (${apiBase}): ${reason}. Using local mode.`);
         }
     }
 
@@ -175,6 +184,8 @@ export async function startMission(prompt, targetUrl) {
         try {
             const projectId = process.env.ARCALITY_PROJECT_ID || loadArcalityConfig()?.projectId;
 
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 5000);
             const res = await fetch(`${apiBase}/api/v1/missions/start`, {
                 method: 'POST',
                 headers: {
@@ -186,8 +197,10 @@ export async function startMission(prompt, targetUrl) {
                     prompt_hash: simpleHash(prompt),
                     target_url: targetUrl,
                     project_id: projectId || undefined,
-                })
+                }),
+                signal: controller.signal
             });
+            clearTimeout(timeout);
 
             if (res.status === 429) {
                 const data = await res.json();
@@ -196,8 +209,9 @@ export async function startMission(prompt, targetUrl) {
             if (!res.ok) return { allowed: false, error: 'server_error' };
 
             return { allowed: true, ...(await res.json()) };
-        } catch {
-            // Fallback to mock if backend is down
+        } catch (e) {
+            const reason = e?.name === 'AbortError' ? 'timeout (5s)' : (e?.message || 'unknown');
+            console.warn(`⚠️  startMission failed (${apiBase}): ${reason}. Falling back to mock mode.`);
         }
     }
 
@@ -236,7 +250,7 @@ export async function startMission(prompt, targetUrl) {
  * @param {'success'|'failed'|'cancelled'} result
  * @param {object} usage - Optional usage statistics directly from the AI
  */
-export async function endMission(missionId, result, usage = null) {
+export async function endMission(missionId, result, usage = null, failReason = null) {
     const apiBase = getEffectiveApiBase();
     if (!apiBase || !missionId) return { ok: true };
 
@@ -248,7 +262,7 @@ export async function endMission(missionId, result, usage = null) {
                 'Content-Type': 'application/json',
                 'x-api-key': key
             },
-            body: JSON.stringify({ result, usage })
+            body: JSON.stringify({ result, usage, failReason })
         });
     } catch { }
     return { ok: true };
@@ -266,3 +280,33 @@ function simpleHash(str) {
     }
     return 'ph_' + Math.abs(hash).toString(36);
 }
+
+/**
+ * Obtiene el Token SAS y el path base para subir evidencias.
+ * @param {string} missionId
+ * @param {string} projectId
+ */
+export async function getEvidenceSasToken(missionId, projectId) {
+    const apiBase = getEffectiveApiBase();
+    if (!apiBase || !missionId || !projectId) return null;
+
+    const key = getEffectiveApiKey();
+    if (!key) return null;
+
+    try {
+        const res = await fetch(`${apiBase}/api/v1/missions/${missionId}/evidence/sas`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${key}`
+            },
+            body: JSON.stringify({ projectId })
+        });
+
+        if (!res.ok) return null;
+        
+        return await res.json();
+    } catch {
+        return null;
+    }
+}

package/src/configLoader.mjs

@@ -18,7 +18,8 @@ export const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
  * @returns {string}
  */
 export function getApiUrl() {
-    return process.env.ARCALITY_API_URL || 'https://arcalityqadev.arcadial.lat';
+    // return 'https://arcalityqadev.arcadial.lat';
+    return 'https://arcalityqadev.arcadial.lat';
 }
 
 /**

package/src/index.ts

@@ -2,13 +2,31 @@ import 'dotenv/config';
 import { showBanner } from './consoleBanner';
 import { promptAndRunPlaywrightTests } from './testRunner';
 import { KnowledgeService } from './KnowledgeService';
-import { ArcalityClient } from './arcalityClient';
+import { ArcalityClient, validateApiKey } from './arcalityClient';
 import { loadConfig } from './configLoader';
+import chalk from 'chalk';
 
 async function main() {
   showBanner();
 
   const config = loadConfig();
+
+  // Validar API Key y obtener contexto de organización
+  console.log(chalk.blue('Validating API Key...'));
+  const auth = await validateApiKey();
+  if (auth.valid) {
+    const orgId = auth.organization_id || auth.organizationId || auth.OrganizationId;
+    if (orgId) {
+      process.env.ARCALITY_ORG_ID = orgId;
+      console.log(chalk.green(`✅ Session initialized for organization: ${auth.organization_name || auth.organizationName || auth.OrganizationName || orgId}`));
+    } else {
+      console.warn(chalk.yellow('⚠️  API Key is valid but no organization_id was returned.'));
+    }
+  } else {
+    console.error(chalk.red(`❌ Invalid API Key: ${auth.error || 'Unknown error'}`));
+    process.exit(1);
+  }
+
   const arcalityClient = new ArcalityClient(config.ARCALITY_API_KEY);
   const knowledgeService = KnowledgeService.getInstance();
 

package/src/services/collectiveMemoryService.ts

@@ -11,18 +11,32 @@
  */
 
 const getBase = () => process.env.ARCALITY_API_URL ? `${process.env.ARCALITY_API_URL}/api/v1` : null;
-const getKey  = () => process.env.ARCALITY_API_KEY || '';
-const getPid  = () => process.env.ARCALITY_PROJECT_ID || '';
+const getKey = () => process.env.ARCALITY_API_KEY || '';
+const getPid = () => process.env.ARCALITY_PROJECT_ID || '';
+const getOrgId = () => process.env.ARCALITY_ORG_ID;
+const getMissionId = () => process.env.ARCALITY_MISSION_ID || EMPTY_GUID;
 
 const EMPTY_GUID = '00000000-0000-0000-0000-000000000000';
 
+let configWarningLogged = false;
+
 function isConfigured(): boolean {
     const base = getBase();
-    const key  = getKey();
-    const pid  = getPid();
+    const key = getKey();
+    const pid = getPid();
+    const orgId = getOrgId();
 
-    if (!base || !key || !pid || pid === EMPTY_GUID) {
-        // Silencioso — no loguear en cada percepción para no hacer ruido
+    if (!base || !key || !pid || pid === EMPTY_GUID || !orgId) {
+        if (!configWarningLogged) {
+            const missing = [];
+            if (!base) missing.push('ARCALITY_API_URL');
+            if (!key) missing.push('ARCALITY_API_KEY');
+            if (!pid || pid === EMPTY_GUID) missing.push('ARCALITY_PROJECT_ID');
+            if (!orgId) missing.push('ARCALITY_ORG_ID');
+            
+            console.warn(`[CollectiveMemory] Service disabled. Missing: ${missing.join(', ')}`);
+            configWarningLogged = true;
+        }
         return false;
     }
     return true;
@@ -48,6 +62,7 @@ export async function pushRule(rule: {
                 'x-api-key': getKey()
             },
             body: JSON.stringify({
+                organization_id: getOrgId(),
                 project_id: getPid(),
                 rule_type: rule.rule_type,
                 title: rule.title.substring(0, 100),
@@ -98,6 +113,7 @@ export async function pushField(field: {
                 'x-api-key': getKey()
             },
             body: JSON.stringify({
+                organization_id: getOrgId(),
                 project_id: getPid(),
                 page_id: field.page_id ?? null,
                 field_identifier: field.field_identifier.substring(0, 100),
@@ -138,6 +154,7 @@ export async function pushKnowledge(knowledge: {
                 'x-api-key': getKey()
             },
             body: JSON.stringify({
+                organization_id: getOrgId(),
                 project_id: getPid(),
                 doc_type: knowledge.doc_type,
                 title: knowledge.title.substring(0, 150),
@@ -160,13 +177,87 @@ export async function pushKnowledge(knowledge: {
     }
 }
 
+// ─── 4. PROMPT EXECUTION PATTERNS ─────────────────────────────────────────────
+
+export async function searchPromptPattern(prompt: string, limit: number = 5): Promise<any[]> {
+    if (!isConfigured()) return [];
+    try {
+        const apiUrl = process.env.ARCALITY_API_URL ? `${process.env.ARCALITY_API_URL}/api/v1/prompt-execution-patterns/search` : `${getBase()}/prompt-execution-patterns/search`;
+
+        const payload = {
+            organization_id: getOrgId(),
+            project_id: getPid(),
+            prompt: prompt,
+            limit: limit
+        };
+
+        console.log(`[PatternSearch] 🔍 Buscando patrones en: ${apiUrl}`);
+        console.log(`[PatternSearch] 📦 Payload: ${JSON.stringify(payload, null, 2)}`);
+
+        const res = await fetch(apiUrl, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': getKey()
+            },
+            body: JSON.stringify(payload)
+        });
+
+        if (!res.ok) {
+            console.warn(`[PatternSearch] HTTP ${res.status} from ${apiUrl}`);
+            return [];
+        }
+        const data = await res.json();
+        const results = Array.isArray(data) ? data : (data.matches || data.results || []);
+        console.log(`[PatternSearch] ✅ ${results.length} patrones encontrados.`);
+        return results;
+    } catch (err: any) {
+        console.warn(`[PatternSearch] ⚠️ Error buscando patrones: ${err?.message || 'unknown'}`);
+        return [];
+    }
+}
+
+export async function savePromptPattern(patternData: any): Promise<boolean> {
+    if (!isConfigured()) return false;
+    try {
+        const apiUrl = process.env.ARCALITY_API_URL ? `${process.env.ARCALITY_API_URL}/api/v1/prompt-execution-patterns` : `${getBase()}/prompt-execution-patterns`;
+
+        const payload = {
+            organization_id: getOrgId(),
+            project_id: getPid(),
+            mission_id: getMissionId(),
+            ...patternData
+        };
+        console.log(`[PatternSave] 📤 POST ${apiUrl} | org=${payload.organization_id} proj=${payload.project_id} mission=${payload.mission_id}`);
+
+        const res = await fetch(apiUrl, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': getKey()
+            },
+            body: JSON.stringify(payload)
+        });
+
+        if (!res.ok) {
+            console.warn(`[PatternSave] ⚠️ HTTP ${res.status} al guardar patrón en ${apiUrl}: ${await res.text().catch(() => '')}`);
+        } else {
+            console.log(`[PatternSave] ✅ Patrón guardado exitosamente.`);
+        }
+        return res.ok;
+    } catch (err: any) {
+        console.warn(`[PatternSave] ⚠️ Error guardando patrón: ${err?.message || 'unknown'}`);
+        return false;
+    }
+}
+
 // ─── HELPER: Obtener campos ya conocidos para deduplicación ─────────────────
 
 export async function getKnownFieldIdentifiers(pathUrl: string): Promise<string[]> {
     if (!isConfigured()) return [];
     try {
         const res = await fetch(
-            `${getBase()}/portal/context?project_id=${getPid()}&path=${encodeURIComponent(pathUrl)}`,
+            `${getBase()}/portal/context?organization_id=${getOrgId()}&project_id=${getPid()}&path=${encodeURIComponent(pathUrl)}`,
             { headers: { 'x-api-key': getKey() } }
         );
         if (!res.ok) return [];