Add Excel Add-in v2.1.0 with static files

- Added FastAPI StaticFiles support for serving Add-in
- Added /static directory with manifest.xml, HTML, JS, CSS
- Updated app/main.py with StaticFiles mounts and /manifest.xml endpoint
- Updated Dockerfile to include static/ directory
- CORS configured for HF Space URL and Office Add-ins
- Version bumped to 2.1.0

Excel Add-in features:
- Univariate Forecast
- Multi-Series Forecast
- Forecast with Covariates (NEW)
- Scenario Analysis (NEW)
- Multivariate Forecast (NEW)
- Anomaly Detection
- Backtest

Users can now load the Add-in directly from:
https://ttzzs-chronos2-excel-forecasting-api.hf.space/manifest.xml

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>

Dockerfile

@@ -26,6 +26,9 @@ RUN pip install --no-cache-dir --upgrade pip && \
 # Copiar código de la aplicación
 COPY app/ ./app/
 
+# Copiar archivos estáticos del Excel Add-in
+COPY static/ ./static/
+
 # Crear usuario no-root
 RUN useradd -m -u 1000 user && \
     chown -R user:user /app

app/main.py

@@ -5,6 +5,8 @@ import numpy as np
 import pandas as pd
 from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
 from pydantic import BaseModel, Field
 
 from chronos import Chronos2Pipeline
@@ -18,18 +20,24 @@ MODEL_ID = os.getenv("CHRONOS_MODEL_ID", "amazon/chronos-2")
 DEVICE_MAP = os.getenv("DEVICE_MAP", "cpu")  # "cpu" o "cuda"
 
 app = FastAPI(
-    title="Chronos-2 Universal Forecasting API",
+    title="Chronos-2 Universal Forecasting API + Excel Add-in",
     description=(
-        "Servidor local (Docker) para pronósticos con Chronos-2: univariante, "
-        "multivariante, covariables, escenarios, anomalías y backtesting."
+        "Servidor para pronósticos con Chronos-2: univariante, "
+        "multivariante, covariables, escenarios, anomalías y backtesting. "
+        "Incluye Excel Add-in v2.1.0 con archivos estáticos."
     ),
-    version="1.0.0",
+    version="2.1.0",
 )
 
 # Configurar CORS para Excel Add-in
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["https://localhost:3001", "https://localhost:3000"],
+    allow_origins=[
+        "https://localhost:3001",
+        "https://localhost:3000",
+        "https://ttzzs-chronos2-excel-forecasting-api.hf.space",
+        "*"  # Permitir todos los orígenes para Office Add-ins
+    ],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
@@ -38,6 +46,72 @@ app.add_middleware(
 # Carga única del modelo al iniciar el proceso
 pipeline = Chronos2Pipeline.from_pretrained(MODEL_ID, device_map=DEVICE_MAP)
 
+# =========================
+# Archivos estáticos para Excel Add-in
+# =========================
+
+# Montar directorios estáticos si existen
+if os.path.exists("static"):
+    app.mount("/assets", StaticFiles(directory="static/assets"), name="assets")
+    app.mount("/taskpane", StaticFiles(directory="static/taskpane"), name="taskpane")
+    app.mount("/commands", StaticFiles(directory="static/commands"), name="commands")
+    
+    # Endpoint para manifest.xml
+    @app.get("/manifest.xml", response_class=FileResponse)
+    async def get_manifest():
+        """Devuelve el manifest.xml del Excel Add-in"""
+        return FileResponse("static/manifest.xml", media_type="application/xml")
+    
+    @app.get("/", tags=["Info"])
+    async def root_with_addon():
+        """Información del API + Add-in"""
+        return {
+            "name": "Chronos-2 Forecasting API",
+            "version": "2.1.0",
+            "model": MODEL_ID,
+            "endpoints": {
+                "api": [
+                    "/health",
+                    "/forecast_univariate",
+                    "/forecast_multi_id",
+                    "/forecast_with_covariates",
+                    "/forecast_multivariate",
+                    "/forecast_scenarios",
+                    "/detect_anomalies",
+                    "/backtest_simple"
+                ],
+                "add_in": [
+                    "/manifest.xml",
+                    "/taskpane/taskpane.html",
+                    "/assets/icon-*.png"
+                ]
+            },
+            "docs": "/docs",
+            "excel_add_in": {
+                "manifest_url": "https://ttzzs-chronos2-excel-forecasting-api.hf.space/manifest.xml",
+                "version": "2.1.0",
+                "features": [
+                    "Univariate Forecast",
+                    "Multi-Series Forecast",
+                    "Forecast with Covariates",
+                    "Scenario Analysis",
+                    "Multivariate Forecast",
+                    "Anomaly Detection",
+                    "Backtest"
+                ]
+            }
+        }
+else:
+    @app.get("/", tags=["Info"])
+    async def root_api_only():
+        """Información del API (sin Add-in)"""
+        return {
+            "name": "Chronos-2 Forecasting API",
+            "version": "2.1.0",
+            "model": MODEL_ID,
+            "docs": "/docs"
+        }
+
 
 # =========================
 # Modelos Pydantic comunes

static/commands/commands.html

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8" />
+    <script type="text/javascript" src="https://appsforoffice.microsoft.com/lib/1/hosted/office.js"></script>
+</head>
+<body>
+    <!-- Ribbon commands handler -->
+    <script>
+        Office.onReady(() => {
+            console.log('Chronos2 commands loaded');
+        });
+    </script>
+</body>
+</html>

static/manifest.xml

@@ -0,0 +1,105 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<OfficeApp xmlns="http://schemas.microsoft.com/office/appforoffice/1.1"
+           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+           xmlns:bt="http://schemas.microsoft.com/office/officeappbasictypes/1.0"
+           xmlns:ov="http://schemas.microsoft.com/office/taskpaneappversionoverrides"
+           xsi:type="TaskPaneApp">
+  
+  <!-- Configuración básica -->
+  <Id>c8a6e7f2-3d4b-4f5a-8b9c-1e2d3f4a5b6c</Id>
+  <Version>2.1.0</Version>
+  <ProviderName>Chronos2 Forecasting</ProviderName>
+  <DefaultLocale>en-US</DefaultLocale>
+  
+  <!-- Información de visualización -->
+  <DisplayName DefaultValue="Chronos2 Forecasting v2.1" />
+  <Description DefaultValue="AI-powered time series forecasting with Chronos-2. Now with Covariates, Scenarios, and Multivariate support!"/>
+  <IconUrl DefaultValue="https://ttzzs-chronos2-excel-forecasting-api.hf.space/assets/icon-32.png"/>
+  <HighResolutionIconUrl DefaultValue="https://ttzzs-chronos2-excel-forecasting-api.hf.space/assets/icon-64.png"/>
+  <SupportUrl DefaultValue="https://ttzzs-chronos2-excel-forecasting-api.hf.space"/>
+  
+  <!-- Hosts soportados -->
+  <Hosts>
+    <Host Name="Workbook" />
+  </Hosts>
+  
+  <DefaultSettings>
+    <SourceLocation DefaultValue="https://ttzzs-chronos2-excel-forecasting-api.hf.space/taskpane/taskpane.html"/>
+  </DefaultSettings>
+  
+  <!-- Permisos -->
+  <Permissions>ReadWriteDocument</Permissions>
+  
+  <!-- Versión específica para Excel -->
+  <VersionOverrides xmlns="http://schemas.microsoft.com/office/taskpaneappversionoverrides" xsi:type="VersionOverridesV1_0">
+    <Hosts>
+      <Host xsi:type="Workbook">
+        
+        <!-- Ribbon personalizado -->
+        <DesktopFormFactor>
+          <GetStarted>
+            <Title resid="GetStarted.Title"/>
+            <Description resid="GetStarted.Description"/>
+            <LearnMoreUrl resid="GetStarted.LearnMoreUrl"/>
+          </GetStarted>
+          
+          <FunctionFile resid="Commands.Url" />
+          
+          <ExtensionPoint xsi:type="PrimaryCommandSurface">
+            <OfficeTab id="TabHome">
+              <Group id="CommandsGroup">
+                <Label resid="CommandsGroup.Label" />
+                <Icon>
+                  <bt:Image size="16" resid="Icon.16x16" />
+                  <bt:Image size="32" resid="Icon.32x32" />
+                  <bt:Image size="80" resid="Icon.80x80" />
+                </Icon>
+                
+                <!-- Botón principal -->
+                <Control xsi:type="Button" id="TaskpaneButton">
+                  <Label resid="TaskpaneButton.Label" />
+                  <Supertip>
+                    <Title resid="TaskpaneButton.Label" />
+                    <Description resid="TaskpaneButton.Tooltip" />
+                  </Supertip>
+                  <Icon>
+                    <bt:Image size="16" resid="Icon.16x16" />
+                    <bt:Image size="32" resid="Icon.32x32" />
+                    <bt:Image size="80" resid="Icon.80x80" />
+                  </Icon>
+                  <Action xsi:type="ShowTaskpane">
+                    <TaskpaneId>ButtonId1</TaskpaneId>
+                    <SourceLocation resid="Taskpane.Url" />
+                  </Action>
+                </Control>
+              </Group>
+            </OfficeTab>
+          </ExtensionPoint>
+        </DesktopFormFactor>
+      </Host>
+    </Hosts>
+    
+    <!-- Recursos -->
+    <Resources>
+      <bt:Images>
+        <bt:Image id="Icon.16x16" DefaultValue="https://ttzzs-chronos2-excel-forecasting-api.hf.space/assets/icon-16.png"/>
+        <bt:Image id="Icon.32x32" DefaultValue="https://ttzzs-chronos2-excel-forecasting-api.hf.space/assets/icon-32.png"/>
+        <bt:Image id="Icon.80x80" DefaultValue="https://ttzzs-chronos2-excel-forecasting-api.hf.space/assets/icon-80.png"/>
+      </bt:Images>
+      <bt:Urls>
+        <bt:Url id="GetStarted.LearnMoreUrl" DefaultValue="https://ttzzs-chronos2-excel-forecasting-api.hf.space"/>
+        <bt:Url id="Commands.Url" DefaultValue="https://ttzzs-chronos2-excel-forecasting-api.hf.space/commands/commands.html"/>
+        <bt:Url id="Taskpane.Url" DefaultValue="https://ttzzs-chronos2-excel-forecasting-api.hf.space/taskpane/taskpane.html"/>
+      </bt:Urls>
+      <bt:ShortStrings>
+        <bt:String id="GetStarted.Title" DefaultValue="Get started with Chronos2!" />
+        <bt:String id="CommandsGroup.Label" DefaultValue="Chronos2" />
+        <bt:String id="TaskpaneButton.Label" DefaultValue="Forecasting" />
+      </bt:ShortStrings>
+      <bt:LongStrings>
+        <bt:String id="GetStarted.Description" DefaultValue="AI-powered forecasting loaded successfully. Click the Forecasting button to start." />
+        <bt:String id="TaskpaneButton.Tooltip" DefaultValue="Open Chronos2 Forecasting panel with v2.1.0 features: Covariates, Scenarios, Multivariate" />
+      </bt:LongStrings>
+    </Resources>
+  </VersionOverrides>
+</OfficeApp>

static/taskpane/taskpane.css

@@ -0,0 +1,308 @@
+/* ====================================================================
+   CHRONOS2 FORECASTING ADD-IN - STYLES
+   ==================================================================== */
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+    font-size: 14px;
+    line-height: 1.5;
+    color: #333;
+    background: #f5f7fa;
+    padding: 0;
+    margin: 0;
+}
+
+.container {
+    max-width: 100%;
+    padding: 16px;
+}
+
+/* Header */
+.header {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    padding: 20px;
+    margin: -16px -16px 20px -16px;
+    text-align: center;
+    box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+}
+
+.header h1 {
+    font-size: 24px;
+    margin-bottom: 4px;
+}
+
+.subtitle {
+    font-size: 12px;
+    opacity: 0.9;
+}
+
+/* Status Card */
+.status-card {
+    background: white;
+    border-radius: 8px;
+    padding: 12px;
+    margin-bottom: 16px;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+}
+
+.status-indicator {
+    display: flex;
+    align-items: center;
+    font-size: 13px;
+}
+
+.status-indicator .dot {
+    width: 10px;
+    height: 10px;
+    border-radius: 50%;
+    margin-right: 8px;
+    animation: pulse 2s infinite;
+}
+
+.status-indicator.online .dot {
+    background: #10b981;
+}
+
+.status-indicator.offline .dot {
+    background: #ef4444;
+    animation: none;
+}
+
+@keyframes pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.5; }
+}
+
+/* Tabs */
+.tabs {
+    display: flex;
+    gap: 4px;
+    margin-bottom: 16px;
+    background: white;
+    padding: 4px;
+    border-radius: 8px;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+}
+
+.tab {
+    flex: 1;
+    background: transparent;
+    border: none;
+    padding: 8px 12px;
+    font-size: 12px;
+    font-weight: 500;
+    color: #666;
+    border-radius: 6px;
+    cursor: pointer;
+    transition: all 0.2s;
+}
+
+.tab:hover {
+    background: #f3f4f6;
+}
+
+.tab.active {
+    background: #667eea;
+    color: white;
+}
+
+/* Tab Content */
+.tab-content {
+    display: none;
+}
+
+.tab-content.active {
+    display: block;
+}
+
+/* Cards */
+.card {
+    background: white;
+    border-radius: 8px;
+    padding: 16px;
+    margin-bottom: 16px;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+}
+
+.card h2 {
+    font-size: 16px;
+    margin-bottom: 8px;
+    color: #1f2937;
+}
+
+.card p {
+    font-size: 13px;
+    color: #6b7280;
+    margin-bottom: 12px;
+}
+
+/* Form Groups */
+.form-group {
+    margin-bottom: 12px;
+}
+
+.form-group label {
+    display: block;
+    font-size: 12px;
+    font-weight: 500;
+    margin-bottom: 4px;
+    color: #374151;
+}
+
+.form-group input,
+.form-group select {
+    width: 100%;
+    padding: 8px 12px;
+    border: 1px solid #d1d5db;
+    border-radius: 6px;
+    font-size: 13px;
+    transition: border-color 0.2s;
+}
+
+.form-group input:focus,
+.form-group select:focus {
+    outline: none;
+    border-color: #667eea;
+    box-shadow: 0 0 0 3px rgba(102, 126, 234, 0.1);
+}
+
+/* Buttons */
+.btn {
+    width: 100%;
+    padding: 10px 16px;
+    border: none;
+    border-radius: 6px;
+    font-size: 13px;
+    font-weight: 600;
+    cursor: pointer;
+    transition: all 0.2s;
+    margin-top: 8px;
+}
+
+.btn-primary {
+    background: #667eea;
+    color: white;
+}
+
+.btn-primary:hover {
+    background: #5568d3;
+    transform: translateY(-1px);
+    box-shadow: 0 4px 8px rgba(102, 126, 234, 0.3);
+}
+
+.btn-secondary {
+    background: #10b981;
+    color: white;
+}
+
+.btn-secondary:hover {
+    background: #059669;
+    transform: translateY(-1px);
+    box-shadow: 0 4px 8px rgba(16, 185, 129, 0.3);
+}
+
+.btn:active {
+    transform: translateY(0);
+}
+
+/* Info Box */
+.info-box {
+    background: #eff6ff;
+    border-left: 3px solid #3b82f6;
+    padding: 12px;
+    border-radius: 4px;
+    font-size: 12px;
+    margin-bottom: 12px;
+    color: #1e40af;
+}
+
+/* Results Card */
+.results-card {
+    background: white;
+    border-radius: 8px;
+    padding: 16px;
+    margin-top: 16px;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+}
+
+.results-card h3 {
+    font-size: 14px;
+    margin-bottom: 12px;
+    color: #1f2937;
+}
+
+.results-log {
+    max-height: 200px;
+    overflow-y: auto;
+    font-family: 'Monaco', 'Courier New', monospace;
+    font-size: 11px;
+    background: #f9fafb;
+    padding: 8px;
+    border-radius: 4px;
+}
+
+.log-entry {
+    padding: 4px 0;
+    border-bottom: 1px solid #e5e7eb;
+}
+
+.log-entry:last-child {
+    border-bottom: none;
+}
+
+.log-entry .timestamp {
+    color: #9ca3af;
+    margin-right: 8px;
+}
+
+.log-success {
+    color: #059669;
+}
+
+.log-error {
+    color: #dc2626;
+}
+
+.log-info {
+    color: #3b82f6;
+}
+
+/* Footer */
+.footer {
+    text-align: center;
+    padding: 16px;
+    margin-top: 20px;
+    font-size: 11px;
+    color: #9ca3af;
+}
+
+.footer .version {
+    margin-top: 4px;
+    color: #d1d5db;
+}
+
+/* Scrollbar */
+.results-log::-webkit-scrollbar {
+    width: 6px;
+}
+
+.results-log::-webkit-scrollbar-track {
+    background: #f1f1f1;
+    border-radius: 3px;
+}
+
+.results-log::-webkit-scrollbar-thumb {
+    background: #888;
+    border-radius: 3px;
+}
+
+.results-log::-webkit-scrollbar-thumb:hover {
+    background: #555;
+}

static/taskpane/taskpane.html

@@ -0,0 +1,218 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>Chronos2 Forecasting</title>
+
+    <!-- Office JavaScript API -->
+    <script type="text/javascript" src="https://appsforoffice.microsoft.com/lib/1/hosted/office.js"></script>
+    
+    <!-- Estilos -->
+    <link rel="stylesheet" href="taskpane.css" />
+</head>
+
+<body>
+    <div class="container">
+        <!-- Header -->
+        <header class="header">
+            <h1>🔮 Chronos2 Forecasting</h1>
+            <p class="subtitle">AI-Powered Time Series Forecasting</p>
+        </header>
+
+        <!-- Status del servidor -->
+        <div class="status-card">
+            <div class="status-indicator" id="serverStatus">
+                <span class="dot"></span>
+                <span id="statusText">Checking server...</span>
+            </div>
+        </div>
+
+        <!-- Tabs -->
+        <div class="tabs">
+            <button class="tab active" onclick="showTab('basic')">Basic</button>
+            <button class="tab" onclick="showTab('multi')">Multi-Series</button>
+            <button class="tab" onclick="showTab('covariates')">Covariates</button>
+            <button class="tab" onclick="showTab('scenarios')">Scenarios</button>
+        </div>
+
+        <!-- Tab 1: Funciones Básicas -->
+        <div id="tab-basic" class="tab-content active">
+            <div class="card">
+                <h2>📊 Univariate Forecast</h2>
+                <p>Select a range with your time series data</p>
+                
+                <div class="form-group">
+                    <label>Prediction Length:</label>
+                    <input type="number" id="predictionLength" value="7" min="1" max="365" />
+                </div>
+                
+                <div class="form-group">
+                    <label>Frequency:</label>
+                    <select id="frequency">
+                        <option value="D">Daily</option>
+                        <option value="W">Weekly</option>
+                        <option value="M">Monthly</option>
+                        <option value="H">Hourly</option>
+                        <option value="Q">Quarterly</option>
+                    </select>
+                </div>
+                
+                <button class="btn btn-primary" onclick="forecastUnivariate()">
+                    🚀 Generate Forecast
+                </button>
+            </div>
+
+            <div class="card">
+                <h2>🔍 Anomaly Detection</h2>
+                <p>Detect outliers in your data</p>
+                
+                <div class="form-group">
+                    <label>Context Length:</label>
+                    <input type="number" id="contextLength" value="20" min="5" />
+                </div>
+                
+                <div class="form-group">
+                    <label>Recent Points:</label>
+                    <input type="number" id="recentPoints" value="7" min="1" />
+                </div>
+                
+                <button class="btn btn-secondary" onclick="detectAnomalies()">
+                    🔍 Detect Anomalies
+                </button>
+            </div>
+
+            <div class="card">
+                <h2>📈 Backtest</h2>
+                <p>Evaluate model accuracy</p>
+                
+                <div class="form-group">
+                    <label>Test Length:</label>
+                    <input type="number" id="testLength" value="7" min="1" />
+                </div>
+                
+                <button class="btn btn-secondary" onclick="runBacktest()">
+                    📈 Run Backtest
+                </button>
+            </div>
+        </div>
+
+        <!-- Tab 2: Multi-Series -->
+        <div id="tab-multi" class="tab-content">
+            <div class="card">
+                <h2>📊 Multi-Series Forecast</h2>
+                <p>Select data with multiple series (ID column + values)</p>
+                
+                <div class="info-box">
+                    <strong>Expected format:</strong><br>
+                    Column A: Series ID<br>
+                    Column B: Date<br>
+                    Column C: Value
+                </div>
+                
+                <div class="form-group">
+                    <label>Prediction Length:</label>
+                    <input type="number" id="multiPredLength" value="7" min="1" />
+                </div>
+                
+                <button class="btn btn-primary" onclick="forecastMultiSeries()">
+                    🚀 Forecast All Series
+                </button>
+            </div>
+        </div>
+
+        <!-- Tab 3: Covariates -->
+        <div id="tab-covariates" class="tab-content">
+            <div class="card">
+                <h2>🎯 Forecast with Covariates</h2>
+                <p>Include explanatory variables (price, promotions, etc.)</p>
+                
+                <div class="info-box">
+                    <strong>Expected format:</strong><br>
+                    Col A: Date<br>
+                    Col B: Target variable<br>
+                    Col C+: Covariates (price, promo, etc.)<br>
+                    <br>
+                    Future rows: Only covariates filled
+                </div>
+                
+                <div class="form-group">
+                    <label>Prediction Length:</label>
+                    <input type="number" id="covPredLength" value="7" min="1" />
+                </div>
+                
+                <div class="form-group">
+                    <label>Covariate Columns:</label>
+                    <input type="text" id="covariateNames" value="price,promotion,temperature" 
+                           placeholder="comma-separated names" />
+                </div>
+                
+                <button class="btn btn-primary" onclick="forecastWithCovariates()">
+                    🎯 Generate Forecast
+                </button>
+            </div>
+
+            <div class="card">
+                <h2>🎲 What-If Scenarios</h2>
+                <p>Compare multiple scenarios</p>
+                
+                <div class="form-group">
+                    <label>Number of Scenarios:</label>
+                    <input type="number" id="numScenarios" value="3" min="1" max="10" />
+                </div>
+                
+                <button class="btn btn-secondary" onclick="generateScenarios()">
+                    🎲 Generate Scenarios
+                </button>
+            </div>
+        </div>
+
+        <!-- Tab 4: Scenarios -->
+        <div id="tab-scenarios" class="tab-content">
+            <div class="card">
+                <h2>🔮 Multivariate Forecast</h2>
+                <p>Multiple target variables simultaneously</p>
+                
+                <div class="info-box">
+                    <strong>Expected format:</strong><br>
+                    Col A: Date<br>
+                    Col B+: Multiple targets (sales, returns, stock, etc.)
+                </div>
+                
+                <div class="form-group">
+                    <label>Prediction Length:</label>
+                    <input type="number" id="multivarPredLength" value="7" min="1" />
+                </div>
+                
+                <div class="form-group">
+                    <label>Target Columns:</label>
+                    <input type="text" id="targetColumns" value="sales,returns,stock" 
+                           placeholder="comma-separated column names" />
+                </div>
+                
+                <button class="btn btn-primary" onclick="forecastMultivariate()">
+                    🔮 Generate Forecast
+                </button>
+            </div>
+        </div>
+
+        <!-- Log de resultados -->
+        <div class="results-card">
+            <h3>📋 Results</h3>
+            <div id="results" class="results-log">
+                Ready to forecast...
+            </div>
+        </div>
+
+        <!-- Footer -->
+        <footer class="footer">
+            <p>Powered by Amazon Chronos-2 🤖</p>
+            <p class="version">v2.1.0 - Full Featured</p>
+        </footer>
+    </div>
+
+    <!-- Scripts -->
+    <script src="taskpane.js"></script>
+</body>
+</html>

static/taskpane/taskpane.js

@@ -0,0 +1,956 @@
+/* global Office, Excel, console */
+
+// ====================================================================
+// CHRONOS2 FORECASTING ADD-IN
+// Office.js Task Pane Implementation
+// ====================================================================
+
+// URL del API en HuggingFace Spaces
+const API_BASE_URL = 'https://ttzzs-chronos2-excel-forecasting-api.hf.space';
+
+// Para desarrollo local, descomenta la siguiente línea:
+// const API_BASE_URL = 'https://localhost:8000';
+
+// Inicializar cuando Office esté listo
+Office.onReady((info) => {
+    if (info.host === Office.HostType.Excel) {
+        console.log('Chronos2 Add-in loaded successfully');
+        checkServerStatus();
+        
+        // Auto-check cada 30 segundos
+        setInterval(checkServerStatus, 30000);
+    }
+});
+
+// ====================================================================
+// UTILIDADES
+// ====================================================================
+
+function log(message, type = 'info') {
+    const resultsDiv = document.getElementById('results');
+    const timestamp = new Date().toLocaleTimeString();
+    const icon = type === 'success' ? '✅' : type === 'error' ? '❌' : 'ℹ️';
+    
+    const entry = document.createElement('div');
+    entry.className = `log-entry log-${type}`;
+    entry.innerHTML = `<span class="timestamp">${timestamp}</span> ${icon} ${message}`;
+    
+    resultsDiv.insertBefore(entry, resultsDiv.firstChild);
+    
+    // Limitar a 20 entries
+    while (resultsDiv.children.length > 20) {
+        resultsDiv.removeChild(resultsDiv.lastChild);
+    }
+}
+
+async function checkServerStatus() {
+    try {
+        const response = await fetch(`${API_BASE_URL}/health`, {
+            method: 'GET',
+            headers: { 'Content-Type': 'application/json' }
+        });
+        
+        const data = await response.json();
+        
+        if (response.ok) {
+            updateServerStatus(true, `Connected - ${data.model_id}`);
+        } else {
+            updateServerStatus(false, 'Server error');
+        }
+    } catch (error) {
+        updateServerStatus(false, 'Server offline');
+    }
+}
+
+function updateServerStatus(isOnline, message) {
+    const statusEl = document.getElementById('serverStatus');
+    const textEl = document.getElementById('statusText');
+    
+    statusEl.className = `status-indicator ${isOnline ? 'online' : 'offline'}`;
+    textEl.textContent = message;
+}
+
+function showTab(tabName) {
+    // Ocultar todos los tabs
+    const tabs = document.querySelectorAll('.tab-content');
+    tabs.forEach(tab => tab.classList.remove('active'));
+    
+    const buttons = document.querySelectorAll('.tab');
+    buttons.forEach(btn => btn.classList.remove('active'));
+    
+    // Mostrar el tab seleccionado
+    document.getElementById(`tab-${tabName}`).classList.add('active');
+    event.target.classList.add('active');
+}
+
+// ====================================================================
+// FUNCIONES DE EXCEL (Office.js)
+// ====================================================================
+
+async function getSelectedRange() {
+    return Excel.run(async (context) => {
+        const range = context.workbook.getSelectedRange();
+        range.load('values, address');
+        await context.sync();
+        
+        return {
+            values: range.values,
+            address: range.address
+        };
+    });
+}
+
+async function writeToRange(data, startCell) {
+    return Excel.run(async (context) => {
+        try {
+            console.log(`[writeToRange] Writing ${data?.length || 0} rows to ${startCell}`);
+            console.log('[writeToRange] Data:', JSON.stringify(data).substring(0, 200));
+            
+            if (!data || data.length === 0) {
+                throw new Error('No data to write');
+            }
+            
+            if (!data[0] || data[0].length === 0) {
+                throw new Error('Invalid data structure: empty first row');
+            }
+            
+            const sheet = context.workbook.worksheets.getActiveWorksheet();
+            const numRows = data.length;
+            const numCols = data[0].length;
+            
+            console.log(`[writeToRange] Creating range: ${numRows} rows x ${numCols} cols from ${startCell}`);
+            
+            const range = sheet.getRange(startCell).getResizedRange(numRows - 1, numCols - 1);
+            
+            range.values = data;
+            range.format.autofitColumns();
+            
+            await context.sync();
+            
+            console.log('[writeToRange] ✅ Data written successfully');
+        } catch (error) {
+            console.error('[writeToRange] ❌ Error:', error);
+            console.error('[writeToRange] Stack:', error.stack);
+            throw error;
+        }
+    });
+}
+
+async function writeForecastResults(timestamps, median, q10, q90, startRow) {
+    return Excel.run(async (context) => {
+        try {
+            console.log('[writeForecastResults] Starting...');
+            console.log(`[writeForecastResults] timestamps: ${timestamps?.length || 0} items`);
+            console.log(`[writeForecastResults] median: ${median?.length || 0} items`);
+            console.log(`[writeForecastResults] q10: ${q10?.length || 0} items`);
+            console.log(`[writeForecastResults] q90: ${q90?.length || 0} items`);
+            console.log(`[writeForecastResults] startRow: ${startRow}`);
+            
+            // VALIDACIÓN
+            if (!timestamps || !median) {
+                throw new Error('Invalid data: timestamps or median is undefined');
+            }
+            
+            if (timestamps.length === 0) {
+                throw new Error('No forecast data received (empty timestamps)');
+            }
+            
+            if (timestamps.length !== median.length) {
+                throw new Error(`Data mismatch: ${timestamps.length} timestamps vs ${median.length} median values`);
+            }
+            
+            const sheet = context.workbook.worksheets.getActiveWorksheet();
+            
+            // Preparar datos
+            const data = [];
+            data.push(['Timestamp', 'Median', 'Q10', 'Q90']); // Headers
+            
+            for (let i = 0; i < timestamps.length; i++) {
+                data.push([
+                    timestamps[i],
+                    median[i],
+                    q10 ? q10[i] : '',
+                    q90 ? q90[i] : ''
+                ]);
+            }
+            
+            console.log(`[writeForecastResults] Prepared ${data.length} rows (including header)`);
+            
+            // Escribir en columnas D-G a partir de la fila especificada
+            const startCell = `D${startRow}`;
+            console.log(`[writeForecastResults] Writing to ${startCell}`);
+            
+            await writeToRange(data, startCell);
+        
+            // Aplicar formato
+            const headerRange = sheet.getRange(`D${startRow}:G${startRow}`);
+            headerRange.format.font.bold = true;
+            headerRange.format.fill.color = '#4472C4';
+            headerRange.format.font.color = 'white';
+            
+            await context.sync();
+            
+            console.log('[writeForecastResults] ✅ Forecast results written successfully');
+        } catch (error) {
+            console.error('[writeForecastResults] ❌ Error:', error);
+            console.error('[writeForecastResults] Stack:', error.stack);
+            throw error;
+        }
+    });
+}
+
+// ====================================================================
+// FUNCIÓN 1: PRONÓSTICO UNIVARIANTE
+// ====================================================================
+
+async function forecastUnivariate() {
+    log('Starting univariate forecast...');
+    
+    try {
+        // Leer rango seleccionado
+        const selection = await getSelectedRange();
+        const values = selection.values.flat().filter(v => v !== '' && !isNaN(v));
+        
+        if (values.length < 3) {
+            log('Error: Select at least 3 data points', 'error');
+            return;
+        }
+        
+        log(`Selected ${values.length} data points from ${selection.address}`);
+        
+        // Obtener parámetros
+        const predictionLength = parseInt(document.getElementById('predictionLength').value);
+        const frequency = document.getElementById('frequency').value;
+        
+        // Construir request
+        const requestBody = {
+            prediction_length: predictionLength,
+            series: { values: values },
+            start_timestamp: new Date().toISOString().split('T')[0],
+            freq: frequency,
+            quantile_levels: [0.1, 0.5, 0.9]
+        };
+        
+        log('Sending request to API...');
+        
+        // Llamar a la API
+        const response = await fetch(`${API_BASE_URL}/forecast_univariate`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(requestBody)
+        });
+        
+        if (!response.ok) {
+            throw new Error(`API error: ${response.statusText}`);
+        }
+        
+        const data = await response.json();
+        
+        log(`Received forecast for ${data.timestamps.length} periods`, 'success');
+        
+        // Escribir resultados
+        await Excel.run(async (context) => {
+            const selection = context.workbook.getSelectedRange();
+            selection.load('rowIndex, rowCount');
+            await context.sync();
+            
+            const startRow = selection.rowIndex + selection.rowCount + 2;
+            
+            await writeForecastResults(
+                data.timestamps,
+                data.median,
+                data.quantiles['0.1'],
+                data.quantiles['0.9'],
+                startRow
+            );
+        });
+        
+        log('✨ Forecast written to spreadsheet', 'success');
+        
+    } catch (error) {
+        log(`Error: ${error.message}`, 'error');
+        console.error(error);
+    }
+}
+
+// ====================================================================
+// FUNCIÓN 2: DETECCIÓN DE ANOMALÍAS
+// ====================================================================
+
+async function detectAnomalies() {
+    log('Starting anomaly detection...');
+    
+    try {
+        const selection = await getSelectedRange();
+        const values = selection.values.flat().filter(v => v !== '' && !isNaN(v));
+        
+        const contextLength = parseInt(document.getElementById('contextLength').value);
+        const recentPoints = parseInt(document.getElementById('recentPoints').value);
+        
+        if (values.length < contextLength + recentPoints) {
+            log(`Error: Need at least ${contextLength + recentPoints} points`, 'error');
+            return;
+        }
+        
+        const context = values.slice(0, contextLength);
+        const recent = values.slice(contextLength, contextLength + recentPoints);
+        
+        const requestBody = {
+            context: { values: context },
+            recent_observed: recent,
+            prediction_length: recentPoints,
+            quantile_low: 0.05,
+            quantile_high: 0.95
+        };
+        
+        log('Analyzing data...');
+        
+        const response = await fetch(`${API_BASE_URL}/detect_anomalies`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(requestBody)
+        });
+        
+        if (!response.ok) {
+            throw new Error(`API error: ${response.statusText}`);
+        }
+        
+        const data = await response.json();
+        const anomalyCount = data.anomalies.filter(a => a.is_anomaly).length;
+        
+        if (anomalyCount > 0) {
+            log(`⚠️ Found ${anomalyCount} anomalies!`, 'error');
+            data.anomalies.filter(a => a.is_anomaly).forEach(a => {
+                log(`  Point ${a.index}: value=${a.value.toFixed(2)}, expected=${a.predicted_median.toFixed(2)}`);
+            });
+        } else {
+            log('No anomalies detected ✓', 'success');
+        }
+        
+    } catch (error) {
+        log(`Error: ${error.message}`, 'error');
+        console.error(error);
+    }
+}
+
+// ====================================================================
+// FUNCIÓN 3: BACKTEST
+// ====================================================================
+
+async function runBacktest() {
+    log('Running backtest...');
+    
+    try {
+        const selection = await getSelectedRange();
+        const values = selection.values.flat().filter(v => v !== '' && !isNaN(v));
+        
+        const testLength = parseInt(document.getElementById('testLength').value);
+        
+        if (values.length <= testLength) {
+            log('Error: Series must be longer than test length', 'error');
+            return;
+        }
+        
+        const requestBody = {
+            series: { values: values },
+            prediction_length: testLength,
+            test_length: testLength
+        };
+        
+        log('Evaluating model...');
+        
+        const response = await fetch(`${API_BASE_URL}/backtest_simple`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(requestBody)
+        });
+        
+        if (!response.ok) {
+            throw new Error(`API error: ${response.statusText}`);
+        }
+        
+        const data = await response.json();
+        const metrics = data.metrics;
+        
+        log(`📊 Backtest Results:`, 'success');
+        log(`  MAE:  ${metrics.mae.toFixed(2)}`);
+        log(`  MAPE: ${metrics.mape.toFixed(2)}%`);
+        log(`  WQL:  ${metrics.wql.toFixed(3)}`);
+        
+        // Interpretar resultados
+        if (metrics.mae < 5) {
+            log('  Quality: Excellent ⭐⭐⭐⭐⭐', 'success');
+        } else if (metrics.mae < 10) {
+            log('  Quality: Good ⭐⭐⭐⭐');
+        } else {
+            log('  Quality: Moderate ⭐⭐⭐');
+        }
+        
+    } catch (error) {
+        log(`Error: ${error.message}`, 'error');
+        console.error(error);
+    }
+}
+
+// ====================================================================
+// FUNCIÓN 4: MULTI-SERIES
+// ====================================================================
+
+async function forecastMultiSeries() {
+    log('Starting multi-series forecast...');
+    
+    try {
+        const selection = await getSelectedRange();
+        const data = selection.values;
+        
+        // Agrupar por series_id (columna A)
+        const seriesMap = {};
+        
+        for (let i = 1; i < data.length; i++) { // Skip header
+            const seriesId = data[i][0];
+            const value = data[i][2]; // Columna C
+            
+            if (seriesId && value !== '' && !isNaN(value)) {
+                if (!seriesMap[seriesId]) {
+                    seriesMap[seriesId] = [];
+                }
+                seriesMap[seriesId].push(parseFloat(value));
+            }
+        }
+        
+        const seriesList = Object.entries(seriesMap).map(([id, values]) => ({
+            series_id: id,
+            values: values
+        }));
+        
+        if (seriesList.length === 0) {
+            log('Error: No valid series found', 'error');
+            return;
+        }
+        
+        log(`Found ${seriesList.length} series`);
+        
+        const predictionLength = parseInt(document.getElementById('multiPredLength').value);
+        
+        const requestBody = {
+            prediction_length: predictionLength,
+            series_list: seriesList,
+            start_timestamp: new Date().toISOString().split('T')[0],
+            freq: 'D',
+            quantile_levels: [0.1, 0.5, 0.9]
+        };
+        
+        log('Forecasting all series...');
+        
+        const response = await fetch(`${API_BASE_URL}/forecast_multi_id`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(requestBody)
+        });
+        
+        if (!response.ok) {
+            throw new Error(`API error: ${response.statusText}`);
+        }
+        
+        const result = await response.json();
+        
+        log(`✨ Generated forecasts for ${result.forecasts.length} series`, 'success');
+        
+        // Escribir resultados (simplificado - solo mostrar en log)
+        result.forecasts.forEach(forecast => {
+            log(`  ${forecast.series_id}: ${forecast.median.length} periods`);
+        });
+        
+    } catch (error) {
+        log(`Error: ${error.message}`, 'error');
+        console.error(error);
+    }
+}
+
+// ====================================================================
+// FUNCIÓN 5: COVARIABLES
+// ====================================================================
+
+async function forecastWithCovariates() {
+    log('Starting forecast with covariates...');
+    
+    try {
+        const selection = await getSelectedRange();
+        const data = selection.values;
+        
+        if (data.length < 3) {
+            log('Error: Need at least 3 rows of data', 'error');
+            return;
+        }
+        
+        // Obtener parámetros
+        const predictionLength = parseInt(document.getElementById('covPredLength').value);
+        const covariateNamesInput = document.getElementById('covariateNames').value;
+        const covariateNames = covariateNamesInput.split(',').map(s => s.trim());
+        
+        log(`Reading data with ${covariateNames.length} covariates: ${covariateNames.join(', ')}`);
+        
+        // Estructura esperada:
+        // Col A: Date/Timestamp
+        // Col B: Target value
+        // Col C+: Covariates
+        
+        const context = [];
+        const future = [];
+        
+        for (let i = 1; i < data.length; i++) { // Skip header
+            const timestamp = data[i][0] ? data[i][0].toString() : null;
+            const target = data[i][1];
+            
+            // Leer covariables
+            const covariates = {};
+            for (let j = 0; j < covariateNames.length && j < data[i].length - 2; j++) {
+                const covValue = data[i][j + 2];
+                if (covValue !== '' && !isNaN(covValue)) {
+                    covariates[covariateNames[j]] = parseFloat(covValue);
+                }
+            }
+            
+            // Si tiene target, es contexto histórico
+            if (target !== '' && !isNaN(target)) {
+                context.push({
+                    timestamp: timestamp,
+                    target: parseFloat(target),
+                    covariates: covariates
+                });
+            } 
+            // Si no tiene target pero sí covariables, son valores futuros
+            else if (Object.keys(covariates).length > 0) {
+                future.push({
+                    timestamp: timestamp,
+                    covariates: covariates
+                });
+            }
+        }
+        
+        if (context.length === 0) {
+            log('Error: No historical data found', 'error');
+            return;
+        }
+        
+        log(`Context: ${context.length} points, Future: ${future.length} points`);
+        
+        const requestBody = {
+            context: context,
+            future: future.length > 0 ? future : null,
+            prediction_length: predictionLength,
+            quantile_levels: [0.1, 0.5, 0.9]
+        };
+        
+        log('Calling API with covariates...');
+        
+        const response = await fetch(`${API_BASE_URL}/forecast_with_covariates`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(requestBody)
+        });
+        
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`API error: ${response.statusText} - ${errorText}`);
+        }
+        
+        const result = await response.json();
+        
+        log(`✨ Forecast generated with ${result.pred_df.length} predictions`, 'success');
+        
+        // Escribir resultados en una nueva ubicación
+        await Excel.run(async (context) => {
+            const selection = context.workbook.getSelectedRange();
+            selection.load('rowIndex, rowCount, columnCount');
+            await context.sync();
+            
+            const startRow = selection.rowIndex + selection.rowCount + 2;
+            const startCol = 0;
+            
+            // Crear tabla con los resultados
+            const sheet = context.workbook.worksheets.getActiveWorksheet();
+            
+            // Headers
+            const headers = Object.keys(result.pred_df[0]);
+            const tableData = [headers];
+            
+            // Data rows
+            result.pred_df.forEach(row => {
+                const rowData = headers.map(h => row[h]);
+                tableData.push(rowData);
+            });
+            
+            const outputRange = sheet.getRangeByIndexes(
+                startRow, 
+                startCol, 
+                tableData.length, 
+                headers.length
+            );
+            
+            outputRange.values = tableData;
+            outputRange.format.autofitColumns();
+            
+            // Format header
+            const headerRange = sheet.getRangeByIndexes(startRow, startCol, 1, headers.length);
+            headerRange.format.font.bold = true;
+            headerRange.format.fill.color = '#4472C4';
+            headerRange.format.font.color = 'white';
+            
+            await context.sync();
+        });
+        
+        log('✨ Results written to spreadsheet', 'success');
+        
+    } catch (error) {
+        log(`Error: ${error.message}`, 'error');
+        console.error(error);
+    }
+}
+
+// ====================================================================
+// FUNCIÓN 6: ESCENARIOS
+// ====================================================================
+
+async function generateScenarios() {
+    log('Starting scenario generation...');
+    
+    try {
+        const selection = await getSelectedRange();
+        const data = selection.values;
+        
+        if (data.length < 3) {
+            log('Error: Need at least 3 rows of data', 'error');
+            return;
+        }
+        
+        const numScenarios = parseInt(document.getElementById('numScenarios').value);
+        
+        // Estructura esperada similar a covariates:
+        // Col A: Date, Col B: Target, Col C+: Covariates
+        // Para escenarios, generaremos variaciones de las covariables
+        
+        const context = [];
+        const covariateNames = [];
+        
+        // Detectar nombres de covariables del header
+        for (let j = 2; j < data[0].length; j++) {
+            if (data[0][j]) {
+                covariateNames.push(data[0][j].toString());
+            }
+        }
+        
+        log(`Detected covariates: ${covariateNames.join(', ')}`);
+        
+        // Leer contexto histórico
+        for (let i = 1; i < data.length; i++) {
+            const timestamp = data[i][0] ? data[i][0].toString() : null;
+            const target = data[i][1];
+            
+            if (target !== '' && !isNaN(target)) {
+                const covariates = {};
+                for (let j = 0; j < covariateNames.length && j < data[i].length - 2; j++) {
+                    const covValue = data[i][j + 2];
+                    if (covValue !== '' && !isNaN(covValue)) {
+                        covariates[covariateNames[j]] = parseFloat(covValue);
+                    }
+                }
+                
+                context.push({
+                    timestamp: timestamp,
+                    target: parseFloat(target),
+                    covariates: covariates
+                });
+            }
+        }
+        
+        if (context.length === 0) {
+            log('Error: No historical data found', 'error');
+            return;
+        }
+        
+        // Generar escenarios automáticamente
+        const predictionLength = 7;
+        const scenarios = [];
+        
+        // Calcular valores promedio de covariables para generar variaciones
+        const avgCovariates = {};
+        covariateNames.forEach(name => {
+            const values = context
+                .map(p => p.covariates[name])
+                .filter(v => v !== undefined);
+            avgCovariates[name] = values.length > 0 
+                ? values.reduce((a, b) => a + b, 0) / values.length 
+                : 0;
+        });
+        
+        // Escenario 1: Baseline (promedios)
+        const baselineScenario = {
+            name: 'Baseline',
+            future_covariates: []
+        };
+        
+        for (let i = 0; i < predictionLength; i++) {
+            baselineScenario.future_covariates.push({
+                timestamp: `future_${i+1}`,
+                covariates: {...avgCovariates}
+            });
+        }
+        scenarios.push(baselineScenario);
+        
+        // Escenario 2: Optimista (+20%)
+        if (numScenarios >= 2) {
+            const optimisticScenario = {
+                name: 'Optimistic (+20%)',
+                future_covariates: []
+            };
+            
+            for (let i = 0; i < predictionLength; i++) {
+                const covs = {};
+                covariateNames.forEach(name => {
+                    covs[name] = avgCovariates[name] * 1.2;
+                });
+                optimisticScenario.future_covariates.push({
+                    timestamp: `future_${i+1}`,
+                    covariates: covs
+                });
+            }
+            scenarios.push(optimisticScenario);
+        }
+        
+        // Escenario 3: Pesimista (-20%)
+        if (numScenarios >= 3) {
+            const pessimisticScenario = {
+                name: 'Pessimistic (-20%)',
+                future_covariates: []
+            };
+            
+            for (let i = 0; i < predictionLength; i++) {
+                const covs = {};
+                covariateNames.forEach(name => {
+                    covs[name] = avgCovariates[name] * 0.8;
+                });
+                pessimisticScenario.future_covariates.push({
+                    timestamp: `future_${i+1}`,
+                    covariates: covs
+                });
+            }
+            scenarios.push(pessimisticScenario);
+        }
+        
+        log(`Generated ${scenarios.length} scenarios`);
+        
+        const requestBody = {
+            context: context,
+            scenarios: scenarios,
+            prediction_length: predictionLength,
+            quantile_levels: [0.1, 0.5, 0.9]
+        };
+        
+        log('Calling scenarios API...');
+        
+        const response = await fetch(`${API_BASE_URL}/forecast_scenarios`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(requestBody)
+        });
+        
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`API error: ${response.statusText} - ${errorText}`);
+        }
+        
+        const result = await response.json();
+        
+        log(`✨ Generated ${result.scenarios.length} scenario forecasts`, 'success');
+        
+        // Escribir resultados
+        await Excel.run(async (context) => {
+            const selection = context.workbook.getSelectedRange();
+            selection.load('rowIndex, rowCount');
+            await context.sync();
+            
+            const startRow = selection.rowIndex + selection.rowCount + 2;
+            const sheet = context.workbook.worksheets.getActiveWorksheet();
+            
+            let currentRow = startRow;
+            
+            // Escribir cada escenario
+            result.scenarios.forEach(scenario => {
+                // Header del escenario
+                const scenarioHeaderRange = sheet.getRangeByIndexes(currentRow, 0, 1, 1);
+                scenarioHeaderRange.values = [[`Scenario: ${scenario.name}`]];
+                scenarioHeaderRange.format.font.bold = true;
+                scenarioHeaderRange.format.fill.color = '#70AD47';
+                scenarioHeaderRange.format.font.color = 'white';
+                currentRow++;
+                
+                // Datos del escenario
+                if (scenario.pred_df && scenario.pred_df.length > 0) {
+                    const headers = Object.keys(scenario.pred_df[0]);
+                    const tableData = [headers];
+                    
+                    scenario.pred_df.forEach(row => {
+                        tableData.push(headers.map(h => row[h]));
+                    });
+                    
+                    const dataRange = sheet.getRangeByIndexes(
+                        currentRow,
+                        0,
+                        tableData.length,
+                        headers.length
+                    );
+                    dataRange.values = tableData;
+                    dataRange.format.autofitColumns();
+                    
+                    currentRow += tableData.length + 1; // +1 para separación
+                }
+            });
+            
+            await context.sync();
+        });
+        
+        log('✨ Scenarios written to spreadsheet', 'success');
+        
+    } catch (error) {
+        log(`Error: ${error.message}`, 'error');
+        console.error(error);
+    }
+}
+
+// ====================================================================
+// FUNCIÓN 7: MULTIVARIANTE
+// ====================================================================
+
+async function forecastMultivariate() {
+    log('Starting multivariate forecast...');
+    
+    try {
+        const selection = await getSelectedRange();
+        const data = selection.values;
+        
+        if (data.length < 3) {
+            log('Error: Need at least 3 rows of data', 'error');
+            return;
+        }
+        
+        // Obtener parámetros
+        const predictionLength = parseInt(document.getElementById('multivarPredLength').value);
+        const targetColumnsInput = document.getElementById('targetColumns').value;
+        const targetColumns = targetColumnsInput.split(',').map(s => s.trim());
+        
+        log(`Forecasting ${targetColumns.length} target variables: ${targetColumns.join(', ')}`);
+        
+        // Estructura esperada:
+        // Col A: Date/Timestamp
+        // Col B+: Target variables (múltiples columnas que queremos predecir)
+        
+        const context = [];
+        
+        // Validar que hay suficientes columnas
+        if (data[0].length < targetColumns.length + 1) {
+            log(`Error: Expected ${targetColumns.length + 1} columns but found ${data[0].length}`, 'error');
+            return;
+        }
+        
+        // Leer datos
+        for (let i = 1; i < data.length; i++) { // Skip header
+            const timestamp = data[i][0] ? data[i][0].toString() : null;
+            
+            // Leer todos los targets
+            const targets = {};
+            let hasValidData = false;
+            
+            for (let j = 0; j < targetColumns.length && j < data[i].length - 1; j++) {
+                const value = data[i][j + 1];
+                if (value !== '' && !isNaN(value)) {
+                    targets[targetColumns[j]] = parseFloat(value);
+                    hasValidData = true;
+                }
+            }
+            
+            if (hasValidData) {
+                context.push({
+                    timestamp: timestamp,
+                    targets: targets,
+                    covariates: {} // Sin covariables por ahora
+                });
+            }
+        }
+        
+        if (context.length === 0) {
+            log('Error: No valid data found', 'error');
+            return;
+        }
+        
+        log(`Read ${context.length} data points`);
+        
+        const requestBody = {
+            context: context,
+            target_columns: targetColumns,
+            prediction_length: predictionLength,
+            quantile_levels: [0.1, 0.5, 0.9]
+        };
+        
+        log('Calling multivariate forecast API...');
+        
+        const response = await fetch(`${API_BASE_URL}/forecast_multivariate`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(requestBody)
+        });
+        
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`API error: ${response.statusText} - ${errorText}`);
+        }
+        
+        const result = await response.json();
+        
+        log(`✨ Generated multivariate forecast with ${result.pred_df.length} predictions`, 'success');
+        
+        // Escribir resultados
+        await Excel.run(async (context) => {
+            const selection = context.workbook.getSelectedRange();
+            selection.load('rowIndex, rowCount');
+            await context.sync();
+            
+            const startRow = selection.rowIndex + selection.rowCount + 2;
+            const sheet = context.workbook.worksheets.getActiveWorksheet();
+            
+            // Crear tabla con resultados
+            if (result.pred_df && result.pred_df.length > 0) {
+                const headers = Object.keys(result.pred_df[0]);
+                const tableData = [headers];
+                
+                result.pred_df.forEach(row => {
+                    tableData.push(headers.map(h => row[h]));
+                });
+                
+                const outputRange = sheet.getRangeByIndexes(
+                    startRow,
+                    0,
+                    tableData.length,
+                    headers.length
+                );
+                
+                outputRange.values = tableData;
+                outputRange.format.autofitColumns();
+                
+                // Format header
+                const headerRange = sheet.getRangeByIndexes(startRow, 0, 1, headers.length);
+                headerRange.format.font.bold = true;
+                headerRange.format.fill.color = '#4472C4';
+                headerRange.format.font.color = 'white';
+                
+                await context.sync();
+            }
+        });
+        
+        log('✨ Multivariate forecast written to spreadsheet', 'success');
+        
+    } catch (error) {
+        log(`Error: ${error.message}`, 'error');
+        console.error(error);
+    }
+}