@dozimple/abap-adt 1.0.1 → 1.1.0

package/CHANGELOG.md

@@ -4,6 +4,46 @@ Formato basado en [Keep a Changelog](https://keepachangelog.com/es-ES/1.1.0/). V
 
 ## [Unreleased]
 
+## [1.1.0] - 2026-09-22
+
+Tool nueva y contrato MCP ampliado (salida estructurada, progreso, cancelación) más resiliencia de conexión: el sprint 1 y parte del 2 del plan de mejoras.
+
+### Añadido
+- **Progreso y cancelación** (sprint 2 del plan): las tools largas informan de su avance (`transport_diff` objeto a
+  objeto; `run_atc`, `where_used` y `run_unit_tests` por fase) y el cliente lo recibe como notificaciones de progreso
+  MCP si las pidió. La cancelación del cliente se respeta **entre pasos**: el paso en curso termina (una llamada ADT
+  no se puede abortar) y el siguiente ya no empieza. Una petición cancelada termina como `CANCELLED`, un tipo propio
+  que no cuenta como fallo del servidor ni abre el circuito.
+- **Salida estructurada** (`outputSchema` / `structuredContent` de MCP), sprint 2 del plan: una tool puede declarar
+  `output` y devolver los mismos datos del texto de forma tipada, para que el cliente no tenga que interpretar la
+  prosa. El registro exige que toda respuesta no errónea de esas tools la traiga (si falta es error del servidor,
+  no un éxito a medias) y el SDK la valida contra el esquema antes de responder. Primeras tools: `sql_query` (filas,
+  columnas, valores hasta 500, `truncated`, avisos) y `syntax_check` (errores, avisos y mensajes con línea y
+  severidad). `docs/TOOLS.md` documenta el esquema de salida de cada una.
+- **`revert_source`: volver a una versión anterior con confirmación.** Tras un `write_source` cuya activación falló,
+  el objeto queda con un borrador inactivo encima de la versión activa; la tool vuelve a escribir la versión elegida
+  (`active`: la última activa; `previous`: la anterior a la activa; `N`: una del historial de `object_versions`)
+  pasando por la misma vista previa, huella, bloqueo y orden que cualquier escritura. Nunca revierte por su cuenta:
+  un rollback automático que pisara una versión sin preguntar sería peor que dejar el objeto inactivo.
+- **Resiliencia de conexión** (sprint 1 del plan de mejoras):
+  - **Sesión caducada renovada en las lecturas.** Si una tool de lectura recibe un token CSRF rechazado o un 401 en
+    una sesión que ya había entrado, el servidor descarta el cliente, vuelve a entrar y repite la lectura una vez;
+    la respuesta lo anota. Nunca en escrituras ni ejecuciones: el bloqueo se perdió con la sesión y un reintento
+    podría escribir dos veces. Una contraseña rechazada sigue fallando a la primera y sigue olvidándose.
+  - **Circuit breaker por sistema.** Tres fallos de red en un minuto abren el circuito de ESE sistema durante un
+    minuto: toda tool responde al instante «no se vuelve a intentar durante N s» en vez de esperar 120 s por llamada.
+    Los demás sistemas no se ven afectados; `sap_systems(check=true)` lo cierra y reintenta. Solo cuentan los fallos
+    de red reales de la librería, no los tiempos agotados propios.
+  - **Tiempo máximo por tool** (`timeoutMs`, por defecto 60 s; ATC y diff de orden 180 s, where-used y ABAP Unit
+    120 s). Al vencer, error `NETWORK` con el tiempo y la sugerencia de acotar; no se reintenta.
+
+### Cambiado
+- Insignia de **OpenSSF Best Practices (Passing)** en el README: el proyecto cumple los 67 criterios del nivel
+  Passing, incluidas las sugerencias, con la ficha pública en https://www.bestpractices.dev/projects/14759.
+- El job de publicación usa Node 24, que ya trae npm >= 11.5.1: se quita la instalación global de npm, que no se
+  puede fijar por hash. Un paso comprueba la versión y falla antes de publicar si no la cumple. El build sigue en
+  Node 22, la versión mínima que soporta el servidor.
+
 ## [1.0.1] - 2026-09-22
 
 Versión de mantenimiento: seguimiento de la auditoría de seguridad, procedimiento de commit y pruebas por propiedades.

package/README.es.md

@@ -4,7 +4,7 @@
 
 [English](README.md) · **Español**
 
-[![CI](../../actions/workflows/ci.yml/badge.svg)](../../actions/workflows/ci.yml) ![Node 22+](https://img.shields.io/badge/node-22%2B-2f7d32) ![MCP](https://img.shields.io/badge/MCP-stdio-5a4fcf) ![SAP](https://img.shields.io/badge/SAP-ECC%20%7C%20S%2F4HANA-0a6ed1) ![License](https://img.shields.io/badge/license-Apache--2.0-blue)
+[![CI](../../actions/workflows/ci.yml/badge.svg)](../../actions/workflows/ci.yml) [![OpenSSF Best Practices](https://www.bestpractices.dev/projects/14759/badge)](https://www.bestpractices.dev/projects/14759) ![Node 22+](https://img.shields.io/badge/node-22%2B-2f7d32) ![MCP](https://img.shields.io/badge/MCP-stdio-5a4fcf) ![SAP](https://img.shields.io/badge/SAP-ECC%20%7C%20S%2F4HANA-0a6ed1) ![License](https://img.shields.io/badge/license-Apache--2.0-blue)
 
 **IA que trabaja en tu SAP con las reglas de un consultor senior.**
 
@@ -61,7 +61,7 @@ El agente elige las tools, las encadena y responde con evidencia. Cada respuesta
 | [Consulta de datos](#g-datos) | Preguntar a las tablas con ABAP SQL, de solo lectura y sin tocar material de credenciales. | 2 |
 | [Diagnóstico de incidentes](#g-diagnostico) | Reunir en una conversación lo que antes exigía ST22, SM37, SLG1 y /IWFND/ERROR_LOG. | 4 |
 | [Documentación SAP](#g-documentacion) | Responder con la documentación oficial y comprobar qué sintaxis existe en cada release. | 7 |
-| [Escritura controlada](#g-escritura) | Guardar cambios solo en desarrollo, en la orden correcta y con la sintaxis verificada antes. | 4 |
+| [Escritura controlada](#g-escritura) | Guardar cambios solo en desarrollo, en la orden correcta y con la sintaxis verificada antes. | 5 |
 | [DoZimple Transport Risk](#g-transport-risk) | Decidir si un pase entero puede ir a calidad o productivo, con el porqué en lenguaje de negocio. | 7 |
 | [Operación y crecimiento](#g-operacion) | Ver qué funciona en cada sistema y decidir con datos cuál es la siguiente tool. | 4 |
 <!-- groups:end -->
@@ -187,6 +187,7 @@ la **[referencia completa](docs/TOOLS.md)**.
 | Tool | Qué hace | Acceso |
 |---|---|---|
 | [`write_source`](docs/TOOLS.md#escritura) | **Guardar fuente en SAP.** Sustituye la fuente COMPLETA de un objeto existente (o de un include de clase), en la orden indicada. | escribe (DEV autorizado) |
+| [`revert_source`](docs/TOOLS.md#escritura) | **Volver a una versión anterior.** Deshace un cambio escribiendo de nuevo una versión anterior del objeto: la última activa (para limpiar un borrador inactivo tras un write_source cuya activación falló), la anterior a la activa, o una concreta del historial de object_versions. | escribe (DEV autorizado) |
 | [`activate`](docs/TOOLS.md#escritura) | **Activar objeto.** Activa un objeto y devuelve los mensajes de SAP tal cual (errores con línea, avisos, objetos que quedan inactivos). | escribe (DEV autorizado) |
 | [`write_text_elements`](docs/TOOLS.md#escritura) | **Crear o cambiar símbolos de texto.** Añade o modifica símbolos de texto (o textos de selección) de un programa/clase/grupo, fusionando con los existentes: no borra los que no se mencionan. | escribe (DEV autorizado) |
 | [`create_transport`](docs/TOOLS.md#escritura) | **Crear orden de transporte.** Crea una orden workbench para el paquete de un objeto, ANTES de la primera edición, para que el cambio caiga en la orden del ticket y no en una tarea reutilizada. | escribe (DEV autorizado) |
@@ -291,7 +292,7 @@ Modelo de amenazas con STRIDE y OWASP Top 10 para aplicaciones LLM: **[docs/THRE
 Con la versión exacta y sin scripts de instalación, igual que las dependencias del propio proyecto:
 
 ```sh
-npm install -g --ignore-scripts @dozimple/abap-adt@1.0.1
+npm install -g --ignore-scripts @dozimple/abap-adt@1.1.0
 PKG="$(npm root -g)/@dozimple/abap-adt"
 mkdir -p ~/.config/abap-adt-dozimple && chmod 700 ~/.config/abap-adt-dozimple
 cp "$PKG/config/systems.example.json" ~/.config/abap-adt-dozimple/systems.json   # sistemas, roles y permisos
@@ -307,9 +308,9 @@ Registro en el cliente MCP:
 ```
 
 Cada versión se publica desde el CI con [procedencia de npm](https://docs.npmjs.com/generating-provenance-statements):
-`npm view @dozimple/abap-adt@1.0.1 dist.attestations` muestra la atestación, y la release de GitHub incluye el
+`npm view @dozimple/abap-adt@1.1.0 dist.attestations` muestra la atestación, y la release de GitHub incluye el
 paquete, su bundle de Sigstore (`.sigstore.json`), el mismo bundle como procedencia in-toto (`.intoto.jsonl`)
-y el SBOM. Para comprobarlo: `gh attestation verify dozimple-abap-adt-1.0.1.tgz --repo <owner>/abap-adt-dozimple`.
+y el SBOM. Para comprobarlo: `gh attestation verify dozimple-abap-adt-1.1.0.tgz --repo <owner>/abap-adt-dozimple`.
 
 ### Desde el código fuente
 
@@ -343,7 +344,7 @@ abap-adt-doZimple se construye sobre el trabajo de otros, y lo reconoce: cada to
 <!-- credits:start -->
 | Proyecto | Autor / titular | Licencia | Tipo | Usado en |
 |---|---|---|---|---|
-| [abap-adt-api](https://github.com/marcellourbani/abap-adt-api) | Marcello Urbani | MIT | dependencia | todas (núcleo), `transport_diff`, `transport_contents`, `inactive_objects`, `edit_preflight`, `run_atc` y 22 más |
+| [abap-adt-api](https://github.com/marcellourbani/abap-adt-api) | Marcello Urbani | MIT | dependencia | todas (núcleo), `transport_diff`, `transport_contents`, `inactive_objects`, `edit_preflight`, `run_atc` y 23 más |
 | [Model Context Protocol TypeScript SDK](https://github.com/modelcontextprotocol/typescript-sdk) | Model Context Protocol | MIT | dependencia | todas (núcleo) |
 | [mcp-sap-docs](https://github.com/marianfoo/mcp-sap-docs) | Marian Zeis (marianfoo) | Apache-2.0 | dependencia | `abap_feature_matrix`, `docs_search`, `docs_fetch`, `clean_core_objects`, `clean_core_object`, `abap_lint` y 1 más |
 | [abaplint](https://github.com/abaplint/abaplint) | Lars Hvam y contribuidores | MIT | dependencia | `abap_lint` |

package/README.md

@@ -4,7 +4,7 @@
 
 **English** · [Español](README.es.md)
 
-[![CI](../../actions/workflows/ci.yml/badge.svg)](../../actions/workflows/ci.yml) ![Node 22+](https://img.shields.io/badge/node-22%2B-2f7d32) ![MCP](https://img.shields.io/badge/MCP-stdio-5a4fcf) ![SAP](https://img.shields.io/badge/SAP-ECC%20%7C%20S%2F4HANA-0a6ed1) ![License](https://img.shields.io/badge/license-Apache--2.0-blue)
+[![CI](../../actions/workflows/ci.yml/badge.svg)](../../actions/workflows/ci.yml) [![OpenSSF Best Practices](https://www.bestpractices.dev/projects/14759/badge)](https://www.bestpractices.dev/projects/14759) ![Node 22+](https://img.shields.io/badge/node-22%2B-2f7d32) ![MCP](https://img.shields.io/badge/MCP-stdio-5a4fcf) ![SAP](https://img.shields.io/badge/SAP-ECC%20%7C%20S%2F4HANA-0a6ed1) ![License](https://img.shields.io/badge/license-Apache--2.0-blue)
 
 **AI that works on your SAP system with the rules of a senior consultant.**
 
@@ -62,7 +62,7 @@ and **a failure is never presented as an empty result or as success**.
 | [Data queries](#g-datos) | Query tables with ABAP SQL, read-only, with sensitive and personal data protected. | 2 |
 | [Incident diagnosis](#g-diagnostico) | One conversation for what used to take ST22, SM37, SLG1 and /IWFND/ERROR_LOG. | 4 |
 | [SAP documentation](#g-documentacion) | Answer from official documentation and check which syntax exists in each release. | 7 |
-| [Controlled writes](#g-escritura) | Save changes only in development, in the right transport, previewed and confirmed by a human. | 4 |
+| [Controlled writes](#g-escritura) | Save changes only in development, in the right transport, previewed and confirmed by a human. | 5 |
 | [DoZimple Transport Risk](#g-transport-risk) | Decide whether a whole release can go to QA or production, with the why in business terms. | 7 |
 | [Operations and growth](#g-operacion) | See what works on each system and decide the next tool with data. | 4 |
 <!-- groups:end -->
@@ -188,6 +188,7 @@ Summary per group; each tool's details — parameters, types, defaults, requirem
 | Tool | What it does | Access |
 |---|---|---|
 | [`write_source`](docs/TOOLS.md#escritura) | **Save source to SAP.** Replaces the FULL source of an existing object (or class include) in the given transport, after a preview with syntax check and diff and a human confirmation. | writes (authorized DEV) |
+| [`revert_source`](docs/TOOLS.md#escritura) | **Revert to an earlier version.** Writes back an earlier version of an object (the last active one, the one before it, or a numbered one from object_versions) through the same preview, fingerprint, lock and transport as write_source; never reverts on its own. | writes (authorized DEV) |
 | [`activate`](docs/TOOLS.md#escritura) | **Activate object.** Activates an object and returns SAP's messages as they are (errors with line, warnings, objects left inactive). | writes (authorized DEV) |
 | [`write_text_elements`](docs/TOOLS.md#escritura) | **Create or change text symbols.** Adds or changes text symbols (or selection texts) of a program/class/group, merging with the existing ones: nothing not mentioned is deleted. | writes (authorized DEV) |
 | [`create_transport`](docs/TOOLS.md#escritura) | **Create transport request.** Creates a workbench request for an object's package BEFORE the first edit, so the change lands in the ticket's transport and not in a reused task. | writes (authorized DEV) |
@@ -291,7 +292,7 @@ Designed to pass a Security and Basis review without exceptions. Details: **[SEC
 Pinned to an exact version, without install scripts, like the project's own dependencies:
 
 ```sh
-npm install -g --ignore-scripts @dozimple/abap-adt@1.0.1
+npm install -g --ignore-scripts @dozimple/abap-adt@1.1.0
 PKG="$(npm root -g)/@dozimple/abap-adt"
 mkdir -p ~/.config/abap-adt-dozimple && chmod 700 ~/.config/abap-adt-dozimple
 cp "$PKG/config/systems.example.json" ~/.config/abap-adt-dozimple/systems.json   # systems, roles and permissions
@@ -307,9 +308,9 @@ MCP client registration:
 ```
 
 Every release is published from CI with [npm provenance](https://docs.npmjs.com/generating-provenance-statements):
-`npm view @dozimple/abap-adt@1.0.1 dist.attestations` shows the attestation, and the GitHub release carries the
+`npm view @dozimple/abap-adt@1.1.0 dist.attestations` shows the attestation, and the GitHub release carries the
 tarball, its Sigstore bundle (`.sigstore.json`), the same bundle as in-toto provenance (`.intoto.jsonl`) and the
-SBOM. To check it: `gh attestation verify dozimple-abap-adt-1.0.1.tgz --repo <owner>/abap-adt-dozimple`.
+SBOM. To check it: `gh attestation verify dozimple-abap-adt-1.1.0.tgz --repo <owner>/abap-adt-dozimple`.
 
 ### From source
 
@@ -344,7 +345,7 @@ abap-adt-doZimple is built on other people's work, and says so: each tool lists
 <!-- credits:start -->
 | Project | Author / holder | License | Type | Used in |
 |---|---|---|---|---|
-| [abap-adt-api](https://github.com/marcellourbani/abap-adt-api) | Marcello Urbani | MIT | dependency | all (core), `transport_diff`, `transport_contents`, `inactive_objects`, `edit_preflight`, `run_atc` and 22 more |
+| [abap-adt-api](https://github.com/marcellourbani/abap-adt-api) | Marcello Urbani | MIT | dependency | all (core), `transport_diff`, `transport_contents`, `inactive_objects`, `edit_preflight`, `run_atc` and 23 more |
 | [Model Context Protocol TypeScript SDK](https://github.com/modelcontextprotocol/typescript-sdk) | Model Context Protocol | MIT | dependency | all (core) |
 | [mcp-sap-docs](https://github.com/marianfoo/mcp-sap-docs) | Marian Zeis (marianfoo) | Apache-2.0 | dependency | `abap_feature_matrix`, `docs_search`, `docs_fetch`, `clean_core_objects`, `clean_core_object`, `abap_lint` and 1 more |
 | [abaplint](https://github.com/abaplint/abaplint) | Lars Hvam and contributors | MIT | dependency | `abap_lint` |

package/dist/core/catalog.en.js

@@ -48,6 +48,7 @@ export const TOOLS_EN = {
     abap_lint: "**abaplint on a snippet.** Runs abaplint locally (code never leaves the machine) on an ABAP snippet or source.",
     docs_community_search: "**Search SAP Community.** Searches SAP Community (blogs and questions) by error message, class or concept.",
     write_source: "**Save source to SAP.** Replaces the FULL source of an existing object (or class include) in the given transport, after a preview with syntax check and diff and a human confirmation.",
+    revert_source: "**Revert to an earlier version.** Writes back an earlier version of an object (the last active one, the one before it, or a numbered one from object_versions) through the same preview, fingerprint, lock and transport as write_source; never reverts on its own.",
     activate: "**Activate object.** Activates an object and returns SAP's messages as they are (errors with line, warnings, objects left inactive).",
     write_text_elements: "**Create or change text symbols.** Adds or changes text symbols (or selection texts) of a program/class/group, merging with the existing ones: nothing not mentioned is deleted.",
     create_transport: "**Create transport request.** Creates a workbench request for an object's package BEFORE the first edit, so the change lands in the ticket's transport and not in a reused task.",

package/dist/core/catalog.js

@@ -100,6 +100,7 @@ export const GROUPS = [
         pitch: "Guardar cambios solo en desarrollo, en la orden correcta y con la sintaxis verificada antes.",
         tools: [
             { name: "write_source", credits: ADT },
+            { name: "revert_source", credits: ADT },
             { name: "activate", credits: ADT },
             { name: "write_text_elements", credits: ADT },
             { name: "create_transport", credits: ADT },

package/dist/core/connection.js

@@ -8,6 +8,10 @@ import { normalizeValue, wrapSql } from "./sql.js";
 const CACHE_DIR = join(homedir(), ".cache", "abap-adt-dozimple");
 const DISCOVERY_TTL_MS = 7 * 24 * 3600 * 1000;
 const REQUEST_TIMEOUT_MS = 120_000;
+/** Circuit breaker: N fallos de red en la ventana abren el circuito durante CIRCUIT_OPEN_MS. */
+const CIRCUIT_FAILURES = 3;
+const CIRCUIT_WINDOW_MS = 60_000;
+const CIRCUIT_OPEN_MS = 60_000;
 /**
  * TLS: con caFile se verifica contra ese certificado (lo correcto para un
  * sistema con certificado propio); allowSelfSigned desactiva la verificación
@@ -30,9 +34,44 @@ export class SapConnection {
     reader;
     caps;
     basisRelease;
+    networkFailures = [];
+    openUntil = 0;
     constructor(system) {
         this.system = system;
     }
+    /** Olvida el cliente de lectura (sesión caducada): la siguiente llamada vuelve a entrar. */
+    resetReader() {
+        const old = this.reader;
+        this.reader = undefined;
+        old?.then((c) => c.logout()).catch(() => undefined);
+    }
+    /**
+     * Tres fallos de red en un minuto abren el circuito: durante un minuto ninguna tool intenta nada contra este
+     * sistema y responde al instante. Un sistema caído (VPN, host) dejaba de responder 120 s por cada llamada.
+     */
+    noteNetworkFailure(now = Date.now()) {
+        this.networkFailures = this.networkFailures.filter((t) => now - t < CIRCUIT_WINDOW_MS);
+        this.networkFailures.push(now);
+        if (this.networkFailures.length >= CIRCUIT_FAILURES) {
+            this.openUntil = now + CIRCUIT_OPEN_MS;
+            this.networkFailures = [];
+        }
+    }
+    /** Segundos que faltan para volver a intentar, o 0 si el circuito está cerrado. */
+    circuitOpenFor(now = Date.now()) {
+        return this.openUntil > now ? Math.ceil((this.openUntil - now) / 1000) : 0;
+    }
+    /** Cierra el circuito a mano (sap_systems con check): se vuelve a intentar ya. */
+    resetCircuit() {
+        this.openUntil = 0;
+        this.networkFailures = [];
+    }
+    assertCircuitClosed() {
+        const s = this.circuitOpenFor();
+        if (s) {
+            throw new ToolError("NETWORK", `${this.system.id} no respondió ${CIRCUIT_FAILURES} veces seguidas: no se vuelve a intentar durante ${s} s.`, "sap_systems(check=true) lo reintenta ahora mismo.");
+        }
+    }
     async newClient() {
         const s = this.system;
         const password = await getPassword(s);
@@ -53,6 +92,7 @@ export class SapConnection {
     }
     /** Cliente de lectura, reutilizado entre llamadas. */
     async adt() {
+        this.assertCircuitClosed();
         if (!this.reader) {
             this.reader = this.newClient().then((c) => this.login(c));
             this.reader.catch(() => (this.reader = undefined));
@@ -61,6 +101,7 @@ export class SapConnection {
     }
     /** Ejecuta fn con una sesión stateful propia y la cierra siempre. */
     async stateful(fn) {
+        this.assertCircuitClosed();
         const c = await this.login(await this.newClient());
         c.stateful = session_types.stateful;
         try {

package/dist/core/errors.js

@@ -19,6 +19,9 @@ export function normalizeError(e, systemId) {
     if (e instanceof ToolError)
         return e;
     const any = e;
+    // signal.throwIfAborted() entre pasos de una tool larga: cancelación del cliente, no fallo del servidor.
+    if (any?.name === "AbortError")
+        return new ToolError("CANCELLED", "Cancelado por el cliente antes de terminar.");
     const code = errCode(any);
     if (code && NETWORK_CODES.has(code)) {
         return new ToolError("NETWORK", `No se llega a ${systemId ?? "SAP"} (${code}).`, "¿Está levantada la VPN de ese cliente?");
@@ -50,6 +53,16 @@ export function normalizeError(e, systemId) {
     const message = sanitizeMessage(any?.message ? String(any.message) : String(e));
     return new ToolError("INTERNAL", message || "Error sin mensaje");
 }
+/**
+ * Sesión caducada a mitad de una lectura: token CSRF rechazado, o 401 en una sesión que ya había entrado. El registro
+ * la renueva y repite la lectura UNA vez; nunca una escritura (el bloqueo se perdió con la sesión).
+ */
+export function isSessionExpired(e) {
+    if (isCsrfError(e))
+        return true;
+    const st = e;
+    return (isHttpError(e) && st?.status === 401) || (isAdtError(e) && st?.err === 401);
+}
 export function renderError(te) {
     const labels = {
         NETWORK: "Sin conexión",
@@ -60,6 +73,7 @@ export function renderError(te) {
         CAPABILITY: "No disponible en este sistema",
         MODULE: "Módulo no habilitado",
         INPUT: "Parámetros inválidos",
+        CANCELLED: "Cancelado",
         INTERNAL: "Error interno",
     };
     return `${labels[te.kind]}: ${te.message}${te.hint ? `\n${te.hint}` : ""}\n` +

package/dist/core/registry.js

@@ -3,11 +3,11 @@ import { join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { z } from "zod";
 import { canWrite, resolveSystem } from "./config.js";
-import { normalizeError, renderError, ToolError } from "./errors.js";
+import { isSessionExpired, normalizeError, renderError, ToolError } from "./errors.js";
 import { budget } from "./output.js";
 import { appendAudit, auditArgs } from "./audit.js";
 import { consumeTokenWithState, issueToken } from "./confirm.js";
-import { renderNotes, withNotes } from "./notes.js";
+import { addNote, renderNotes, withNotes } from "./notes.js";
 import { assertAccess } from "./policy.js";
 import { recordUsage } from "./telemetry.js";
 /**
@@ -182,6 +182,15 @@ export async function invoke(def, rawArgs, env) {
                     throw new ToolError("INTERNAL", "No hay componentes auxiliares en este servidor.");
                 return env.sidecars.get(name);
             },
+            signal: env.signal,
+            progress(message, current, total) {
+                try {
+                    env.progress?.(message, current, total);
+                }
+                catch {
+                    /* el progreso es cortesía: un fallo al notificar nunca rompe la tool */
+                }
+            },
         };
         const head = resolved ? `Sistema: ${resolved.system.id} (${resolved.source})\n${SAP_DATA_NOTE}\n\n` : "";
         if (resolved && (def.access === "write" || def.access === "exec")) {
@@ -218,14 +227,23 @@ export async function invoke(def, rawArgs, env) {
                     throw new ToolError("INTERNAL", `No se ejecutó: no se pudo escribir el registro de auditoría (${e.message}).`);
                 }
             }
-            const { result: res, notes } = await withNotes(() => def.run(args, ctx));
+            const { result: res, notes } = await withNotes(() => runGuarded(def, args, ctx, sapConn, systemId));
             const text = renderNotes(notes) + (typeof res === "string" ? res : res.text);
             const isError = typeof res === "string" ? false : !!res.isError;
-            outcome = { text: head + budget(text), isError, kind: isError ? "RESULT" : undefined, system: systemId };
+            const structured = typeof res === "string" ? undefined : res.structured;
+            // Una tool con esquema de salida que responde bien sin datos estructurados es un bug: mejor verlo aquí que
+            // como error críptico del SDK en el cliente.
+            if (def.output && !isError && !structured)
+                throw new ToolError("INTERNAL", `${def.name} declara salida estructurada y no la devolvió.`);
+            outcome = { text: head + budget(text), isError, kind: isError ? "RESULT" : undefined, system: systemId, structured };
         }
     }
     catch (e) {
         let te = normalizeError(e, systemId);
+        // Solo los fallos de red REALES (de la librería) cuentan para el circuito: ni un timeout nuestro ni el propio
+        // aviso de circuito abierto.
+        if (te.kind === "NETWORK" && !(e instanceof ToolError) && sapConn)
+            sapConn.noteNetworkFailure();
         // Un 404 de SAP (no un «objeto no existe» nuestro) sobre un endpoint que el
         // discovery tampoco lista: ahora sí hay evidencia de que falta la función.
         if (te.kind === "NOT_FOUND" && !(e instanceof ToolError) && missing.length && sapConn) {
@@ -251,6 +269,50 @@ export async function invoke(def, rawArgs, env) {
     });
     return outcome;
 }
+const DEFAULT_TIMEOUT_MS = 60_000;
+function withTimeout(p, ms, what, signal) {
+    let timer;
+    let onAbort;
+    const limit = new Promise((_, reject) => {
+        if (signal) {
+            onAbort = () => reject(new ToolError("CANCELLED", `${what}: cancelado por el cliente.`));
+            if (signal.aborted)
+                onAbort();
+            else
+                signal.addEventListener("abort", onAbort, { once: true });
+        }
+        timer = setTimeout(() => reject(new ToolError("NETWORK", `${what}: tiempo agotado (${ms >= 1000 ? `${Math.round(ms / 1000)} s` : `${ms} ms`}).`, "Acota la petición (menos objetos, más filtro) o repite más tarde.")), ms);
+    });
+    return Promise.race([p, limit]).finally(() => {
+        clearTimeout(timer);
+        if (signal && onAbort)
+            signal.removeEventListener("abort", onAbort);
+    });
+}
+/**
+ * Ejecuta la tool con su tiempo máximo y, si la sesión de lectura había caducado (CSRF o 401 tras haber entrado),
+ * la renueva y repite UNA vez. Nunca repite escrituras ni ejecuciones: el bloqueo se perdió con la sesión y un
+ * reintento podría escribir dos veces.
+ */
+async function runGuarded(def, args, ctx, sapConn, systemId) {
+    const ms = def.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const attempt = () => {
+        if (ctx.signal?.aborted)
+            throw new ToolError("CANCELLED", `${def.name}: cancelado por el cliente.`);
+        return withTimeout(def.run(args, ctx), ms, def.name, ctx.signal);
+    };
+    try {
+        return await attempt();
+    }
+    catch (e) {
+        if (def.access === "read" && sapConn && isSessionExpired(e)) {
+            sapConn.resetReader();
+            addNote(`La sesión con ${systemId ?? "SAP"} había caducado: se renovó y la lectura se repitió.`);
+            return await attempt();
+        }
+        throw e;
+    }
+}
 /** Elicitación de formulario, si el cliente la anuncia (ABAP_DZ_CONFIRM=token la desactiva). */
 function elicitFor(server) {
     const caps = server.server.getClientCapabilities()?.elicitation;
@@ -313,10 +375,21 @@ export function registerAll(server, defs, config, pool, sidecars) {
             title: def.title,
             description: describe(def, config),
             inputSchema,
+            ...(def.output ? { outputSchema: z.object(def.output) } : {}),
             annotations: annotationsFor(def),
-        }, (async (args) => {
-            const r = await invoke(def, args ?? {}, { config, pool, tools: defs, sidecars, elicit: elicitFor(server) });
-            return { content: [{ type: "text", text: r.text }], isError: r.isError };
+        }, (async (args, extra) => {
+            const token = extra?._meta?.progressToken;
+            const progress = token !== undefined && extra?.sendNotification
+                ? (message, current, total) => {
+                    void extra.sendNotification({ method: "notifications/progress", params: { progressToken: token, progress: current ?? 0, total, message } }).catch(() => undefined);
+                }
+                : undefined;
+            const r = await invoke(def, args ?? {}, { config, pool, tools: defs, sidecars, elicit: elicitFor(server), signal: extra?.signal, progress });
+            return {
+                content: [{ type: "text", text: r.text }],
+                isError: r.isError,
+                ...(r.structured ? { structuredContent: r.structured } : {}),
+            };
         }));
         published.push(def.name);
     }

package/dist/tools/core/revert_source.js

@@ -0,0 +1,111 @@
+import { z } from "zod";
+import { isError, renderSyntax, syntaxCheck } from "../../core/checks.js";
+import { stateOf } from "../../core/confirm.js";
+import { diffLines, unified } from "../../core/diff.js";
+import { ToolError } from "../../core/errors.js";
+import { CLASS_INCLUDES, resolveObject, sourceUrl, TYPE_HELP } from "../../core/objects.js";
+import { assertTrkorr } from "../../core/policy.js";
+import { versionNumber } from "../../core/revisions.js";
+import { defineTool } from "../../core/tool.js";
+import { transportWarnings } from "../../core/transport.js";
+import writeSource from "./write_source.js";
+/**
+ * Deshacer con confirmación, nunca automático. Tras un write_source cuya activación falló, el objeto queda con un
+ * borrador inactivo (versión 99999 de ADT) encima de la versión activa (00000). Esta tool escribe de nuevo la
+ * versión elegida —la activa, la anterior a la activa, o una concreta del historial— pasando por la misma vista
+ * previa, confirmación, bloqueo y orden que cualquier escritura. Un rollback que pisara una versión sin preguntar
+ * sería peor que dejar el objeto inactivo.
+ */
+const TARGET_HELP = "«active»: la última versión activa (deshace un borrador inactivo, p. ej. un write_source cuya activación falló). " +
+    "«previous»: la versión anterior a la activa (deshace la última activación). " +
+    "Un número N: la versión N tal como la lista object_versions.";
+function pickRevision(revs, target) {
+    if (typeof target === "number") {
+        const rev = revs[target - 1];
+        if (!rev)
+            throw new ToolError("INPUT", `Solo hay ${revs.length} versiones (object_versions las lista).`);
+        return { rev, label: `versión ${target} del historial` };
+    }
+    const active = revs.find((r) => versionNumber(r) === "00000");
+    if (target === "active") {
+        if (!active)
+            throw new ToolError("NOT_FOUND", "SAP no devuelve una versión activa de este objeto.");
+        return { rev: active, label: "última versión activa" };
+    }
+    const numbered = revs
+        .filter((r) => /^\d{5}$/.test(versionNumber(r)) && !["00000", "99999"].includes(versionNumber(r)))
+        .sort((a, b) => (Date.parse(b.date) || 0) - (Date.parse(a.date) || 0) || Number(versionNumber(b)) - Number(versionNumber(a)));
+    if (!numbered.length)
+        throw new ToolError("NOT_FOUND", "No hay ninguna versión grabada anterior a la activa.");
+    return { rev: numbered[0], label: "versión anterior a la activa" };
+}
+async function chosenSource(c, obj, include, target) {
+    const revs = await c.revisions(obj.uri, obj.type.startsWith("CLAS") ? include : undefined);
+    if (!revs.length)
+        throw new ToolError("NOT_FOUND", `${obj.name}: SAP no devuelve versiones para este objeto.`);
+    const { rev, label } = pickRevision(revs, target);
+    const hasDraft = revs.some((r) => versionNumber(r) === "99999");
+    return { rev, label, hasDraft, source: await c.getObjectSource(rev.uri) };
+}
+const input = {
+    object_name: z.string().min(1),
+    object_type: z.string().optional().describe(TYPE_HELP),
+    include: z.enum(CLASS_INCLUDES).default("main"),
+    target: z.union([z.enum(["active", "previous"]), z.number().int().min(1)]).default("active").describe(TARGET_HELP),
+    transport: z.string().optional().describe("Orden (o tarea) donde debe ir la reversión. Obligatoria salvo objetos locales"),
+    activate: z.boolean().default(true),
+};
+export default defineTool({
+    name: "revert_source",
+    title: "Volver a una versión anterior",
+    description: "Deshace un cambio escribiendo de nuevo una versión anterior del objeto: la última activa (para limpiar un " +
+        "borrador inactivo tras un write_source cuya activación falló), la anterior a la activa, o una concreta del " +
+        "historial de object_versions. Pasa por la misma vista previa, confirmación, bloqueo y orden que write_source: " +
+        "nunca revierte por su cuenta. Solo objetos de código fuente.",
+    access: "write",
+    input,
+    async preview({ object_name, object_type, include, target, transport, activate }, { sap, system }) {
+        const requested = transport ? assertTrkorr(transport) : undefined;
+        const c = await sap.adt();
+        const obj = await resolveObject(c, object_name, object_type);
+        const url = await sourceUrl(c, obj, include);
+        const current = await c.getObjectSource(url);
+        const { rev, label, hasDraft, source } = await chosenSource(c, obj, include, target);
+        const out = [
+            `${obj.name} (${obj.type})${include !== "main" ? ` · include ${include}` : ""} · paquete ${obj.packageName ?? "?"}`,
+            `Volver a: ${label} · ${rev.date} · ${rev.author}${rev.versionTitle ? ` · ${rev.versionTitle}` : ""}`,
+            `Orden: ${requested ?? "ninguna indicada (solo vale para objetos locales)"} · activar después: ${activate ? "sí" : "no"}`,
+            hasDraft ? "Estado: el objeto tiene un borrador inactivo (cambios guardados sin activar)." : "Estado: sin borrador inactivo.",
+        ];
+        if (target === "active" && !hasDraft)
+            out.push("Aviso: no hay borrador que deshacer; la versión activa ya es la que se ve.");
+        if (requested) {
+            const warn = await transportWarnings(sap, requested, system.user);
+            out.push(warn.length ? `⚠ AVISOS DE LA ORDEN ${requested}:\n${warn.map((w) => "  ⚠ " + w).join("\n")}` : `Orden ${requested}: modificable, con destino y del usuario de esta conexión.`);
+        }
+        const msgs = await syntaxCheck(c, obj, url, source);
+        out.push(msgs.some(isError) ? `Sintaxis de la versión elegida: CON ERRORES, la escritura se detendrá.\n${renderSyntax(msgs)}` : `Sintaxis de la versión elegida: sin errores${msgs.length ? ` (${msgs.length} avisos)` : ""}.`);
+        const ops = diffLines(current, source);
+        if (!ops)
+            out.push("", "Cambio: el objeto se reescribe casi entero (demasiadas diferencias para mostrarlas como diff).");
+        else {
+            const u = unified(ops, 3);
+            const lines = u.text.split("\n");
+            out.push("", u.hunks ? `Cambio respecto a lo que hay ahora: +${u.added} −${u.removed} en ${u.hunks} bloques` : "Cambio: ninguno (la versión elegida es idéntica a lo que hay ahora).");
+            if (u.hunks)
+                out.push(lines.slice(0, 400).join("\n") + (lines.length > 400 ? `\n[… ${lines.length - 400} líneas más de diff]` : ""));
+        }
+        return { text: out.join("\n"), state: stateOf(current) };
+    },
+    async run({ object_name, object_type, include, target, transport, activate }, ctx) {
+        const c = await ctx.sap.adt();
+        const obj = await resolveObject(c, object_name, object_type);
+        const { label, source } = await chosenSource(c, obj, include, target);
+        // La escritura real es la de write_source: mismo bloqueo, misma comprobación de que nada cambió desde la vista
+        // previa (ctx.confirmedState), misma decisión de orden y misma activación.
+        const r = await writeSource.run({ object_name, object_type, include, source, transport, activate, skip_syntax_check: false }, ctx);
+        const text = typeof r === "string" ? r : r.text;
+        return { text: `Revertido a la ${label}.\n${text}`, isError: typeof r === "string" ? false : !!r.isError };
+    },
+});
+//# sourceMappingURL=revert_source.js.map

package/dist/tools/core/run_atc.js

@@ -10,9 +10,10 @@ import { defineTool } from "../../core/tool.js";
 const decode = decodeEntities;
 const strip = htmlToText;
 /** Ejecuta el ATC del alcance y lo recuerda bajo ese alcance. */
-async function execute(c, sap, systemId, t, o) {
+async function execute(c, sap, systemId, t, o, ctx) {
     const variant = o.variant ?? (await defaultVariant(c));
     let res;
+    ctx?.progress?.(`ATC de ${t.scope} con la variante ${variant}…`);
     try {
         res = await runAtc(c, t.uri, variant, o.max_findings, o.include_exempted);
         res.scope = t.scope;
@@ -35,6 +36,8 @@ async function execute(c, sap, systemId, t, o) {
         const uris = (await Promise.all(refs.map((r) => resolveByTypePrefix(c, r.name, r.types)))).filter(Boolean).map((r) => r.uri);
         if (!uris.length)
             throw new ToolError("NOT_FOUND", `La orden ${tr} no contiene objetos que el ATC pueda revisar.`);
+        ctx?.signal?.throwIfAborted();
+        ctx?.progress?.(`Este release no admite la orden como conjunto: ATC sobre sus ${uris.length} objetos en una corrida…`);
         res = await runAtc(c, uris, variant, o.max_findings, o.include_exempted);
         res.scope = `orden ${tr} (sus ${uris.length} objetos: este release no admite la orden como conjunto ATC)`;
     }
@@ -44,6 +47,7 @@ async function execute(c, sap, systemId, t, o) {
 }
 export default defineTool({
     name: "run_atc",
+    timeoutMs: 180_000,
     title: "Ejecutar ATC",
     description: "Ejecuta el ATC sobre un objeto o una orden de transporte y lista los hallazgos numerados (prioridad, línea, " +
         "check, mensaje), con los totales P1/P2/P3 que da SAP. El resultado queda recordado POR OBJETO U ORDEN: " +
@@ -66,7 +70,8 @@ export default defineTool({
             .optional()
             .describe("Documentación del hallazgo N del ATC del objeto u orden indicados (sin ellos: del último ATC, y lo dice)"),
     },
-    async run(a, { sap, system }) {
+    async run(a, ctx) {
+        const { sap, system } = ctx;
         const c = await sap.adt();
         // El alcance (objeto u orden nombrados) se resuelve antes que nada: explain=N es SIEMPRE de ese alcance.
         let target;
@@ -83,7 +88,7 @@ export default defineTool({
             let run = target ? recallRun(system.id, target.key) : recallRun(system.id);
             let ranNow = false;
             if (!run && target) {
-                run = await execute(c, sap, system.id, target, opts);
+                run = await execute(c, sap, system.id, target, opts, ctx);
                 ranNow = true;
             }
             if (!run)
@@ -99,7 +104,7 @@ export default defineTool({
         }
         if (!target)
             throw new ToolError("INPUT", "Indica object_name o transport.");
-        const res = await execute(c, sap, system.id, target, opts);
+        const res = await execute(c, sap, system.id, target, opts, ctx);
         const shown = res.findings.filter((f) => !a.priorities || a.priorities.includes(f.priority));
         const byPrio = [1, 2, 3, 4].map((p) => res.findings.filter((f) => f.priority === p).length);
         const stats = res.stats ? `SAP: P1 ${res.stats.p1} · P2 ${res.stats.p2} · P3 ${res.stats.p3}` : `P1 ${byPrio[0]} · P2 ${byPrio[1]} · P3 ${byPrio[2]}`;

package/dist/tools/core/run_unit_tests.js

@@ -9,6 +9,7 @@ import { defineTool } from "../../core/tool.js";
 export const SAFE_TEST_FLAGS = { harmless: true, dangerous: false, critical: false, short: true, medium: false, long: false };
 export default defineTool({
     name: "run_unit_tests",
+    timeoutMs: 120_000,
     title: "Ejecutar ABAP Unit",
     description: "Ejecuta los tests ABAP Unit de una clase o programa y devuelve el resultado por método, con el detalle de cada " +
         "fallo. Solo corre tests RISK LEVEL HARMLESS y DURATION SHORT. Si no hay clases de test lo dice: cero tests no es un éxito.",
@@ -20,9 +21,11 @@ export default defineTool({
         object_name: z.string().min(1),
         object_type: z.string().default("CLAS").describe(TYPE_HELP),
     },
-    async run({ object_name, object_type }, { sap }) {
+    async run({ object_name, object_type }, ctx) {
+        const { sap } = ctx;
         const c = await sap.adt();
         const obj = await resolveObject(c, object_name, object_type);
+        ctx.progress?.(`Ejecutando ABAP Unit de ${obj.name} (solo tests harmless y short)…`);
         const classes = await c.unitTestRun(obj.uri, { ...SAFE_TEST_FLAGS });
         if (!classes.length)
             return { text: `${obj.name}: no se encontraron clases de test. No se ejecutó nada.`, isError: true };

package/dist/tools/core/sql_query.js

@@ -2,6 +2,8 @@ import { z } from "zod";
 import { guardedQuery } from "../../core/datapolicy.js";
 import { tsv } from "../../core/output.js";
 import { defineTool } from "../../core/tool.js";
+/** La salida estructurada duplica el contenido del texto: se acota para no doblar respuestas enormes. */
+const STRUCTURED_ROWS = 500;
 export default defineTool({
     name: "sql_query",
     title: "Consulta ABAP SQL",
@@ -14,12 +16,26 @@ export default defineTool({
         query: z.string().min(1).describe("SELECT ... FROM ... WHERE ..."),
         max_rows: z.number().int().min(1).max(5000).default(100),
     },
+    output: {
+        rows: z.number().int().describe("Filas devueltas"),
+        columns: z.array(z.string()),
+        values: z.array(z.record(z.unknown())).describe(`Filas como objetos columna→valor (hasta ${STRUCTURED_ROWS}; el texto las trae todas)`),
+        truncated: z.boolean().describe("true si values no incluye todas las filas"),
+        notes: z.array(z.string()).describe("Avisos de la política de datos (enmascarado, tope de filas)"),
+    },
     async run({ query, max_rows }, { sap, system }) {
         const r = await guardedQuery(sap, system, query, max_rows);
+        const structured = {
+            rows: r.values.length,
+            columns: r.columns,
+            values: r.values.slice(0, STRUCTURED_ROWS),
+            truncated: r.values.length > STRUCTURED_ROWS,
+            notes: r.notes,
+        };
         if (!r.values.length)
-            return `La consulta se ejecutó y no devolvió filas.`;
+            return { text: `La consulta se ejecutó y no devolvió filas.`, structured };
         const table = tsv(r.columns, r.values.map((v) => r.columns.map((c) => v[c])));
-        return `${r.values.length} filas\n\n${table}${r.notes.length ? `\n\n${r.notes.join("\n")}` : ""}`;
+        return { text: `${r.values.length} filas\n\n${table}${r.notes.length ? `\n\n${r.notes.join("\n")}` : ""}`, structured };
     },
 });
 //# sourceMappingURL=sql_query.js.map

package/dist/tools/core/syntax_check.js

@@ -16,6 +16,13 @@ export default defineTool({
         source: z.string().optional().describe("Fuente completa a comprobar (sin guardar)"),
         main_program: z.string().optional().describe("URI del programa principal, solo para includes ambiguos"),
     },
+    output: {
+        object: z.string(),
+        checked: z.enum(["proposed", "saved"]).describe("proposed = la fuente pasada sin guardar; saved = lo último guardado"),
+        errors: z.number().int(),
+        warnings: z.number().int(),
+        messages: z.array(z.object({ severity: z.string(), line: z.number(), offset: z.number(), text: z.string(), uri: z.string() })),
+    },
     async run({ object_name, object_type, include, source, main_program }, { sap }) {
         const c = await sap.adt();
         const obj = await resolveObject(c, object_name, object_type);
@@ -23,12 +30,20 @@ export default defineTool({
         const content = source ?? (await c.getObjectSource(url, { version: "inactive" }));
         const msgs = await syntaxCheck(c, obj, url, content, main_program);
         const what = source ? "fuente propuesta (no guardada)" : "última versión guardada";
-        if (!msgs.length)
-            return `${obj.name}: sin errores ni avisos de sintaxis (${what}, comprobado por SAP).`;
         const errs = msgs.filter(isError).length;
+        const structured = {
+            object: obj.name,
+            checked: source ? "proposed" : "saved",
+            errors: errs,
+            warnings: msgs.length - errs,
+            messages: msgs.map((m) => ({ severity: m.severity ?? "", line: m.line, offset: m.offset, text: m.text, uri: m.uri })),
+        };
+        if (!msgs.length)
+            return { text: `${obj.name}: sin errores ni avisos de sintaxis (${what}, comprobado por SAP).`, structured };
         return {
             text: `${obj.name}: ${errs} errores, ${msgs.length - errs} avisos (${what}).\n\n${renderSyntax(msgs)}`,
             isError: errs > 0,
+            structured,
         };
     },
 });

package/dist/tools/core/transport_diff.js

@@ -22,6 +22,7 @@ async function pool(items, n, fn) {
 }
 export default defineTool({
     name: "transport_diff",
+    timeoutMs: 180_000,
     title: "Qué cambió una orden (diff de código)",
     description: "Revisión de código de una orden: por cada objeto con fuente (programas, includes, clases, interfaces, FM, CDS) " +
         "compara la versión grabada con esa orden (o sus tareas) contra la versión anterior, y muestra el diff unificado. " +
@@ -36,7 +37,8 @@ export default defineTool({
         max_objects: z.number().int().min(1).max(60).default(20),
         max_diff_lines: z.number().int().min(20).max(3000).default(300).describe("Tope de líneas de diff por objeto"),
     },
-    async run({ transport, objects, context, summary_only, max_objects, max_diff_lines }, { sap }) {
+    async run({ transport, objects, context, summary_only, max_objects, max_diff_lines }, ctx) {
+        const { sap } = ctx;
         const tr = assertTrkorr(transport);
         const heads = await orderHeaders(sap, [tr]);
         const head = heads.get(tr);
@@ -51,7 +53,11 @@ export default defineTool({
         const selected = source.filter((s) => !wanted || wanted.includes(s.name.toUpperCase()));
         const shown = selected.slice(0, max_objects);
         const c = await sap.adt();
+        let done = 0;
+        ctx.progress?.(`Comparando ${shown.length} objetos de ${root}…`, 0, shown.length);
         const blocks = await pool(shown, 4, async (ref) => {
+            // Cancelación entre objetos: el que está en curso termina, el siguiente ya no empieza.
+            ctx.signal?.throwIfAborted();
             try {
                 const res = await resolveRef(c, ref);
                 if (!res)
@@ -91,6 +97,9 @@ export default defineTool({
                     throw te;
                 return { name: ref.name, text: `■ ${ref.name}: no se pudo comparar (${te.kind}: ${te.message})`, added: 0, removed: 0 };
             }
+            finally {
+                ctx.progress?.(`${++done} de ${shown.length} objetos comparados`, done, shown.length);
+            }
         });
         const tot = blocks.reduce((a, b) => ({ added: a.added + b.added, removed: a.removed + b.removed }), { added: 0, removed: 0 });
         const out = [

package/dist/tools/core/where_used.js

@@ -4,6 +4,7 @@ import { tsv } from "../../core/output.js";
 import { defineTool } from "../../core/tool.js";
 export default defineTool({
     name: "where_used",
+    timeoutMs: 120_000,
     title: "Dónde se usa",
     description: "Lista de uso (where-used) de un objeto: quién lo referencia, con paquete y responsable. Con snippets=true añade " +
         "las líneas de código de cada uso (más lento). Ojo: no ve usos dinámicos ni exits que no declaran tipos.",
@@ -15,10 +16,13 @@ export default defineTool({
         max_results: z.number().int().min(1).max(1000).default(100),
         snippets: z.boolean().default(false),
     },
-    async run({ object_name, object_type, max_results, snippets }, { sap }) {
+    async run({ object_name, object_type, max_results, snippets }, ctx) {
+        const { sap } = ctx;
         const c = await sap.adt();
         const obj = await resolveObject(c, object_name, object_type);
+        ctx.progress?.(`Buscando usos de ${obj.name} (en objetos muy usados tarda hasta un minuto)…`);
         const refs = (await c.usageReferences(obj.uri)).filter((r) => r.isResult);
+        ctx.signal?.throwIfAborted();
         if (!refs.length)
             return `${obj.name} (${obj.type}): el where-used se ejecutó y no encontró usos estáticos.`;
         const shown = refs.slice(0, max_results);
@@ -27,6 +31,7 @@ export default defineTool({
             "\n\n" +
             tsv(["nombre", "tipo", "paquete", "responsable", "uso"], shown.map((r) => [r["adtcore:name"], r["adtcore:type"], r.packageRef?.["adtcore:name"], r["adtcore:responsible"], r.usageInformation]));
         if (snippets) {
+            ctx.progress?.(`${refs.length} usos; leyendo fragmentos de los primeros ${Math.min(shown.length, 30)}…`);
             const sn = await c.usageReferenceSnippets(shown.slice(0, 30));
             const lines = sn.flatMap((s) => s.snippets.map((x) => `${s.objectIdentifier}  L${x.uri?.start?.line ?? "?"}: ${x.content.trim()}`));
             out += `\n\nFragmentos (hasta 30 objetos):\n${lines.join("\n")}`;

package/dist/tools/local/sap_systems.js

@@ -30,6 +30,10 @@ export default defineTool({
             if (!check)
                 continue;
             const sap = pool.get(s);
+            if (sap.circuitOpenFor()) {
+                out.push("  circuito abierto por fallos de red seguidos: se cierra y se reintenta ahora");
+                sap.resetCircuit();
+            }
             try {
                 const caps = await sap.capabilities(refresh_discovery);
                 const rel = await sap.release();

package/docs/TOOLS.md

@@ -1,6 +1,6 @@
 # Referencia de tools — abap-adt-doZimple
 
-Generado desde el código con `npm run docs`. 47 tools en 9 grupos y 3 flujos guiados.
+Generado desde el código con `npm run docs`. 48 tools en 9 grupos y 3 flujos guiados.
 Producto de [DoZimple](https://dozimple.cl).
 
 ## Índice
@@ -11,7 +11,7 @@ Producto de [DoZimple](https://dozimple.cl).
 - [Consulta de datos](#datos) — 2 tools: `sql_query`, `table_contents`
 - [Diagnóstico de incidentes](#diagnostico) — 4 tools: `dumps`, `jobs`, `application_log`, `gateway_errors`
 - [Documentación SAP](#documentacion) — 7 tools: `abap_feature_matrix`, `docs_search`, `docs_fetch`, `clean_core_objects`, `clean_core_object`, `abap_lint`, `docs_community_search`
-- [Escritura controlada](#escritura) — 4 tools: `write_source`, `activate`, `write_text_elements`, `create_transport`
+- [Escritura controlada](#escritura) — 5 tools: `write_source`, `revert_source`, `activate`, `write_text_elements`, `create_transport`
 - [DoZimple Transport Risk](#transport-risk) — 7 tools: `analyze_transport_risk`, `import_health`, `failure_ranking`, `change_audit`, `object_transport_history`, `remote_source`, `transport_source_check`
 - [Operación y crecimiento](#operacion) — 4 tools: `sap_systems`, `report_gap`, `close_gap`, `usage_stats`
 - [Flujos guiados](#flujos-guiados)
@@ -206,6 +206,16 @@ Chequeo de sintaxis real de SAP (no abaplint). Si pasas `source`, se comprueba E
 
 \* obligatorio
 
+Salida estructurada (`structuredContent`, además del texto):
+
+| Campo | Tipo | Descripción |
+|---|---|---|
+| `object` | string |  |
+| `checked` | `proposed` \| `saved` | proposed = la fuente pasada sin guardar; saved = lo último guardado |
+| `errors` | number |  |
+| `warnings` | number |  |
+| `messages` | lista de { severity, line, offset, text, uri } |  |
+
 ### `run_unit_tests` — Ejecutar ABAP Unit
 
 Ejecuta los tests ABAP Unit de una clase o programa y devuelve el resultado por método, con el detalle de cada fallo. Solo corre tests RISK LEVEL HARMLESS y DURATION SHORT. Si no hay clases de test lo dice: cero tests no es un éxito.
@@ -417,6 +427,16 @@ Ejecuta un SELECT de ABAP SQL (con WHERE, JOIN, ORDER BY, subconsultas) vía la
 
 \* obligatorio
 
+Salida estructurada (`structuredContent`, además del texto):
+
+| Campo | Tipo | Descripción |
+|---|---|---|
+| `rows` | number | Filas devueltas |
+| `columns` | lista de string |  |
+| `values` | lista de record | Filas como objetos columna→valor (hasta 500; el texto las trae todas) |
+| `truncated` | boolean | true si values no incluye todas las filas |
+| `notes` | lista de string | Avisos de la política de datos (enmascarado, tope de filas) |
+
 ### `table_contents` — Contenido de una tabla
 
 Filas de una tabla, vista o CDS, con columnas y filtro opcionales. Atajo de sql_query para el caso típico «enséñame lo que hay en ZTABLA donde …». Para JOIN, subconsultas o agregados usa sql_query.
@@ -684,6 +704,28 @@ Sustituye la fuente COMPLETA de un objeto existente (o de un include de clase),
 
 \* obligatorio
 
+### `revert_source` — Volver a una versión anterior
+
+Deshace un cambio escribiendo de nuevo una versión anterior del objeto: la última activa (para limpiar un borrador inactivo tras un write_source cuya activación falló), la anterior a la activa, o una concreta del historial de object_versions. Pasa por la misma vista previa, confirmación, bloqueo y orden que write_source: nunca revierte por su cuenta. Solo objetos de código fuente.
+
+| | |
+|---|---|
+| **Acceso** | Escribe (solo DEV con `allowWrite`; nunca QAS/PRD) |
+| **Créditos** | [abap-adt-api](https://github.com/marcellourbani/abap-adt-api) — Marcello Urbani (MIT, dependencia) |
+
+| Parámetro | Tipo | Por defecto | Descripción |
+|---|---|---|---|
+| `system` | string |  | Sistema SAP configurado. Obligatorio si hay varios y ninguno por defecto. |
+| `object_name` * | string |  |  |
+| `object_type` | string |  | Tipo corto: PROG, INCL, CLAS, INTF, FUGR, FUNC, DDLS, DDLX, DCLS, TABL, STRU, VIEW, DTEL, DOMA, TTYP, MSAG, XSLT, BDEF, SRVD, SRVB, ENHO. También vale el tipo ADT (p. ej. PROG/P). |
+| `include` | `main` \| `definitions` \| `implementations` \| `macros` \| `testclasses` | "main" |  |
+| `target` | union | "active" | «active»: la última versión activa (deshace un borrador inactivo, p. ej. un write_source cuya activación falló). «previous»: la versión anterior a la activa (deshace la última activación). Un número N: la versión N tal como la lista object_versions. |
+| `transport` | string |  | Orden (o tarea) donde debe ir la reversión. Obligatoria salvo objetos locales |
+| `activate` | boolean | true |  |
+| `confirm_token` | string |  | Token de la vista previa. Sin él la tool no escribe: devuelve qué va a cambiar y el token, que se usa tras la conformidad del usuario (un solo uso, 10 min). |
+
+\* obligatorio
+
 ### `activate` — Activar objeto
 
 Activa un objeto y devuelve los mensajes de SAP tal cual (errores con línea, avisos, objetos que quedan inactivos).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dozimple/abap-adt",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "DoZimple MCP server for SAP ABAP: multi-system, secure by design — code review, ATC, diagnosis and documentation for ECC and S/4HANA",
   "keywords": [
     "sap",