@dozimple/abap-adt 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -4,6 +4,42 @@ Formato basado en [Keep a Changelog](https://keepachangelog.com/es-ES/1.1.0/). V
 
 ## [Unreleased]
 
+## [1.2.0] - 2026-09-23
+
+Cuatro tools para diagnóstico y soporte: dumps agrupados por periodo, búsqueda de texto en el código, estado de notas SAP y ampliaciones/BAdI. Todas verificadas en vivo en un NW 7.50.
+
+### Añadido
+- **`enhancements`: ampliaciones y BAdI.** Tres preguntas en una tool, por SQL de diccionario (7.50 y S/4):
+  implementaciones de una BAdI, nuevas y clásicas, activas o no, con las propias (Z/Y) primero; ampliaciones de código
+  implementadas dentro de un programa, clase o grupo de funciones, avisando de las que **sustituyen** código estándar
+  (overwrite); y todas las implementaciones de un espacio de nombres por tipo, con el total real. Lo que cambia el
+  comportamiento de un estándar sin tocar su código, que es lo primero a mirar en un incidente. Verificado en vivo en
+  un 7.50: 1.070 implementaciones Z (566 de código, 501 de BAdI).
+- **`sap_notes`: estado de notas SAP en el sistema, como en SNOTE**, sin portal ni S-user: si la nota está descargada,
+  estado de implementación y de tratamiento, versión, componente y título (español si existe). Por notas concretas
+  («¿está la 2198647 en PRD?») o filtrando por estado y/o prefijo de componente, con el total real. Distingue «no
+  descargada» de «no implementada». Los códigos de estado no son valores fijos del diccionario: su significado sale de
+  las constantes de SAP (`IF_SCWN_NA_CONSTANTS`), verificadas en un 7.50. En sistemas con datos productivos no se
+  muestra quién trató la nota. Sustituto seguro del MCP de notas de SAP, que usa APIs privadas y el S-user.
+- **`source_search`: buscar texto en el código de un paquete, una orden o una lista de objetos.** Texto literal o
+  expresión regular (máx. 200 caracteres), sin distinguir mayúsculas; devuelve objeto, include, línea y la línea
+  encontrada, con salida estructurada. Lee cada fuente (programas, clases con sus includes locales, interfaces,
+  módulos e includes propios de los grupos de funciones, CDS) con 4 lecturas en paralelo, progreso y cancelación;
+  exige un alcance, tiene tope de objetos (150 por defecto, ~0,8 s por objeto medido en 7.50) y lista aparte los
+  objetos que no pudo leer. Existe porque ADT no tiene búsqueda de texto en NW 7.50 (`textsearch` da 404 y no está
+  en el discovery), y llega donde `where_used` no: verificado en vivo, `where_used` no encontró ningún uso de una
+  clase de excepción y `source_search` encontró 49 en 6 objetos del mismo paquete.
+- **`dumps(group_by, days)`: los errores más frecuentes de un periodo.** Cuenta los dumps de los últimos N días (hasta
+  90) agrupados por error, programa, error+programa, usuario o día, con primer y último caso, usuarios distintos
+  afectados y dónde terminó el más reciente (include y línea); salida estructurada. Los grupos salen de la cabecera
+  de ST22 (`SNAP_BEG.FLIST`, solo metadatos: `SNAP`, que guarda valores de variables, sigue vetada), porque el feed
+  ADT solo trae los dumps más recientes: en un 7.50 real devolvió 5 con miles en ST22, y su parámetro `from` no
+  amplía la ventana. En sistemas con datos productivos no se agrupa por usuario (columna personal); el número de
+  usuarios afectados sí se da. Cierra el hueco anotado el 11-09.
+
+### Corregido
+- `package_contents` listaba objetos **borrados** que TADIR conserva con `DELFLAG = 'X'`; ahora no aparecen.
+
 ## [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.

package/README.es.md

@@ -56,8 +56,8 @@ El agente elige las tools, las encadena y responde con evidencia. Cada respuesta
 | Grupo | Para qué | Tools |
 |---|---|---|
 | [Revisión de código y pases](#g-revision) | Saber qué cambia de verdad una orden y qué puede romper, antes de liberarla. | 5 |
-| [Calidad, ATC y remediación](#g-calidad) | Encontrar, entender y corregir hallazgos con la sintaxis y las correcciones reales de SAP. | 5 |
-| [Exploración del repositorio](#g-exploracion) | Leer y entender cualquier objeto ABAP y sus relaciones, en ECC y en S/4HANA. | 9 |
+| [Calidad, ATC y remediación](#g-calidad) | Encontrar, entender y corregir hallazgos con la sintaxis y las correcciones reales de SAP. | 6 |
+| [Exploración del repositorio](#g-exploracion) | Leer y entender cualquier objeto ABAP y sus relaciones, en ECC y en S/4HANA. | 11 |
 | [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 |
@@ -122,6 +122,7 @@ la **[referencia completa](docs/TOOLS.md)**.
 | [`run_atc`](docs/TOOLS.md#calidad) | **Ejecutar ATC.** 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. | lectura |
 | [`atc_quickfix`](docs/TOOLS.md#calidad) | **Correcciones propuestas por SAP.** Correcciones que SAP ofrece (las mismas de Ctrl+1 en Eclipse) para un hallazgo ATC o una línea: crear símbolo de texto, extraer constante, etc. | lectura |
 | [`api_release_state`](docs/TOOLS.md#calidad) | **¿Está liberada esta API? ¿Cuál es su sucesor?** Estado de liberación de un objeto SAP (clase, FM/BAPI, tabla, CDS…) por contrato C0–C4 y su sucesor liberado, leído del propio sistema. | lectura |
+| [`sap_notes`](docs/TOOLS.md#calidad) | **Notas SAP en el sistema (SNOTE).** Estado de notas SAP en este sistema, como en SNOTE: si está descargada, estado de implementación (completa, incompleta, versión anterior, se puede implementar, obsoleta, no se puede implementar), estado de tratamiento, versión, componente y título. | lectura |
 | [`syntax_check`](docs/TOOLS.md#calidad) | **Chequeo de sintaxis SAP.** Chequeo de sintaxis real de SAP (no abaplint). | lectura |
 | [`run_unit_tests`](docs/TOOLS.md#calidad) | **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. | ejecuta (DEV) |
 
@@ -135,12 +136,14 @@ la **[referencia completa](docs/TOOLS.md)**.
 | [`search_objects`](docs/TOOLS.md#exploracion) | **Buscar objetos ABAP.** Busca objetos del repositorio por nombre (admite * como comodín). | lectura |
 | [`get_source`](docs/TOOLS.md#exploracion) | **Leer fuente ABAP.** Lee la fuente de cualquier objeto: programa, include, clase (y sus includes), interfaz, módulo de función (sin necesidad de saber el grupo), CDS, tabla/estructura, etc. | lectura |
 | [`where_used`](docs/TOOLS.md#exploracion) | **Dónde se usa.** Lista de uso (where-used) de un objeto: quién lo referencia, con paquete y responsable. | lectura |
+| [`source_search`](docs/TOOLS.md#exploracion) | **Buscar texto en el código.** Busca un texto (o una expresión regular) en el código fuente de un paquete (con subpaquetes), de una orden de transporte o de una lista de objetos, y devuelve objeto, include, línea y la línea encontrada. | lectura |
 | [`object_versions`](docs/TOOLS.md#exploracion) | **Versiones de un objeto.** Historial de versiones de un objeto (fecha, autor, orden). | lectura |
 | [`package_contents`](docs/TOOLS.md#exploracion) | **Contenido de un paquete.** Objetos de un paquete de desarrollo agrupados por tipo, con sus subpaquetes (TADIR/TDEVC, cualquier release). | lectura |
 | [`ddic_type_info`](docs/TOOLS.md#exploracion) | **Elemento de datos, dominio o tipo tabla.** Definición de un tipo DDIC: elemento de datos (dominio, tipo, longitud, textos), dominio (tipo, longitud, valores fijos, tabla de valores) o tipo tabla (tipo de línea, clave). | lectura |
 | [`transaction_info`](docs/TOOLS.md#exploracion) | **Qué ejecuta una transacción.** Programa, dynpro y parámetros de una transacción (TSTC/TSTCP), con su texto. | lectura |
 | [`function_modules`](docs/TOOLS.md#exploracion) | **Módulos de función de un grupo.** Lista los módulos de función de un grupo de funciones, con su texto y si son RFC o de actualización. | lectura |
 | [`text_elements`](docs/TOOLS.md#exploracion) | **Símbolos de texto y textos de selección.** Lee los símbolos de texto (TEXT-001…), textos de selección o encabezados de un programa, clase o grupo de funciones. | lectura |
+| [`enhancements`](docs/TOOLS.md#exploracion) | **Ampliaciones y BAdI.** Qué ampliaciones hay y dónde. badi=NOMBRE: implementaciones de esa BAdI, nuevas y clásicas, activas o no. program + program_type (PROG, CLAS, FUGR): ampliaciones de código (puntos y secciones implícitos o explícitos) implementadas dentro de ese programa, clase o grupo — lo que cambia el comportamiento de un estándar sin tocar su código. prefix (p. ej. Z): implementaciones de ampliación de ese espacio de nombres, por tipo. | lectura |
 
 <a id="g-datos"></a>
 ### Consulta de datos
@@ -292,7 +295,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.1.0
+npm install -g --ignore-scripts @dozimple/abap-adt@1.2.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
@@ -308,9 +311,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.1.0 dist.attestations` muestra la atestación, y la release de GitHub incluye el
+`npm view @dozimple/abap-adt@1.2.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.1.0.tgz --repo <owner>/abap-adt-dozimple`.
+y el SBOM. Para comprobarlo: `gh attestation verify dozimple-abap-adt-1.2.0.tgz --repo <owner>/abap-adt-dozimple`.
 
 ### Desde el código fuente
 
@@ -344,7 +347,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 23 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 26 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` |
@@ -359,7 +362,7 @@ abap-adt-doZimple se construye sobre el trabajo de otros, y lo reconoce: cada to
 | [ABAP Remote FS (vscode_abap_remote_fs)](https://github.com/marcellourbani/vscode_abap_remote_fs) | Marcello Urbani | MIT | idea | `syntax_check` |
 | [mcp-abap-adt](https://github.com/mario-andreschak/mcp-abap-adt) | mario-andreschak | MIT | idea | `search_objects`, `get_source`, `package_contents`, `ddic_type_info`, `transaction_info`, `table_contents` |
 | [ARC-1](https://github.com/arc-mcp/arc-1) | arc-mcp (Marian Zeis y contribuidores) | MIT | idea | `transport_diff`, `atc_quickfix`, `gateway_errors` |
-| [vibing-steampunk](https://github.com/oisee/vibing-steampunk) | oisee y contribuidores | MIT | idea | `co_change`, `api_release_state`, `jobs`, `application_log` |
+| [vibing-steampunk](https://github.com/oisee/vibing-steampunk) | oisee y contribuidores | MIT | idea | `co_change`, `api_release_state`, `source_search`, `enhancements`, `jobs`, `application_log` |
 | [ABAP Accelerator for Amazon Q Developer](https://github.com/aws-solutions-library-samples/guidance-for-deploying-sap-abap-accelerator-for-amazon-q-developer) | AWS Solutions Library Samples | MIT-0 | idea | todas (núcleo), `usage_stats` |
 | [An O(ND) Difference Algorithm and Its Variations (1986)](https://doi.org/10.1007/BF01840446) | Eugene W. Myers | algoritmo publicado | algoritmo | `transport_diff`, `atc_quickfix` |
 <!-- credits:end -->

package/README.md

@@ -57,8 +57,8 @@ and **a failure is never presented as an empty result or as success**.
 | Group | What for | Tools |
 |---|---|---|
 | [Code review and transports](#g-revision) | Know what a transport really changes and what it may break, before releasing it. | 5 |
-| [Quality, ATC and remediation](#g-calidad) | Find, understand and fix findings with SAP's real syntax check and quick fixes. | 5 |
-| [Repository exploration](#g-exploracion) | Read and understand any ABAP object and its relations, on ECC and S/4HANA. | 9 |
+| [Quality, ATC and remediation](#g-calidad) | Find, understand and fix findings with SAP's real syntax check and quick fixes. | 6 |
+| [Repository exploration](#g-exploracion) | Read and understand any ABAP object and its relations, on ECC and S/4HANA. | 11 |
 | [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 |
@@ -123,6 +123,7 @@ Summary per group; each tool's details — parameters, types, defaults, requirem
 | [`run_atc`](docs/TOOLS.md#calidad) | **Run ATC.** Runs the ABAP Test Cockpit on an object or a transport and lists numbered findings (priority, line, check, message) with SAP's P1/P2/P3 totals. | read |
 | [`atc_quickfix`](docs/TOOLS.md#calidad) | **SAP-proposed fixes.** The fixes SAP offers (the same as Ctrl+1 in Eclipse) for an ATC finding or a line: create text symbol, extract constant, etc. | read |
 | [`api_release_state`](docs/TOOLS.md#calidad) | **Is this API released? What is its successor?** Release state of an SAP object (class, function module/BAPI, table, CDS…) by contract C0–C4 and its released successor, read from the system itself. | read |
+| [`sap_notes`](docs/TOOLS.md#calidad) | **SAP notes in the system (SNOTE).** Whether a note is downloaded in this system, its implementation and processing status, version, component and title, per note or filtered by status/component; no SAP portal or S-user needed. | read |
 | [`syntax_check`](docs/TOOLS.md#calidad) | **SAP syntax check.** SAP's real syntax check (not abaplint), also on code not saved yet. | read |
 | [`run_unit_tests`](docs/TOOLS.md#calidad) | **Run ABAP Unit.** Runs the ABAP Unit tests of a class or program (harmless and short only) and returns the result per method, with each failure in detail. | executes (DEV) |
 
@@ -136,12 +137,14 @@ Summary per group; each tool's details — parameters, types, defaults, requirem
 | [`search_objects`](docs/TOOLS.md#exploracion) | **Search ABAP objects.** Searches repository objects by name (supports * wildcards). | read |
 | [`get_source`](docs/TOOLS.md#exploracion) | **Read ABAP source.** Reads the source of any object: program, include, class (and its includes), interface, function module (without knowing its group), CDS, table/structure, etc. | read |
 | [`where_used`](docs/TOOLS.md#exploracion) | **Where used.** Where-used list of an object: who references it, with package and owner. | read |
+| [`source_search`](docs/TOOLS.md#exploracion) | **Search text in source code.** Searches a text or regex in the source of a package (with subpackages), a transport or a list of objects, and returns object, include, line and the matching line; reaches what where-used misses (dynamic calls, literals, Z code outside the reference index). | read |
 | [`object_versions`](docs/TOOLS.md#exploracion) | **Object versions.** Version history of an object (date, author, transport). | read |
 | [`package_contents`](docs/TOOLS.md#exploracion) | **Package contents.** Objects of a development package grouped by type, with subpackages (TADIR/TDEVC, any release). | read |
 | [`ddic_type_info`](docs/TOOLS.md#exploracion) | **Data element, domain or table type.** Definition of a DDIC type: data element (domain, type, length, texts), domain (type, length, fixed values, value table) or table type (line type, key). | read |
 | [`transaction_info`](docs/TOOLS.md#exploracion) | **What a transaction runs.** Program, screen and parameters of a transaction (TSTC/TSTCP), with its text. | read |
 | [`function_modules`](docs/TOOLS.md#exploracion) | **Function modules of a group.** Lists the function modules of a function group with their text and whether they are RFC or update modules; given a module, finds its group and siblings. Works with /XXX/ namespaces. | read |
 | [`text_elements`](docs/TOOLS.md#exploracion) | **Text symbols and selection texts.** Reads the text symbols (TEXT-001…), selection texts or headings of a program, class or function group. | read |
+| [`enhancements`](docs/TOOLS.md#exploracion) | **Enhancements and BAdIs.** Implementations of a BAdI (new and classic, active or not), source code enhancements implemented inside a program, class or function group (flagging those that overwrite standard code), or all enhancement implementations of a namespace by type. | read |
 
 <a id="g-datos"></a>
 ### Data queries
@@ -292,7 +295,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.1.0
+npm install -g --ignore-scripts @dozimple/abap-adt@1.2.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
@@ -308,9 +311,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.1.0 dist.attestations` shows the attestation, and the GitHub release carries the
+`npm view @dozimple/abap-adt@1.2.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.1.0.tgz --repo <owner>/abap-adt-dozimple`.
+SBOM. To check it: `gh attestation verify dozimple-abap-adt-1.2.0.tgz --repo <owner>/abap-adt-dozimple`.
 
 ### From source
 
@@ -345,7 +348,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 23 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 26 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` |
@@ -360,7 +363,7 @@ abap-adt-doZimple is built on other people's work, and says so: each tool lists
 | [ABAP Remote FS (vscode_abap_remote_fs)](https://github.com/marcellourbani/vscode_abap_remote_fs) | Marcello Urbani | MIT | idea | `syntax_check` |
 | [mcp-abap-adt](https://github.com/mario-andreschak/mcp-abap-adt) | mario-andreschak | MIT | idea | `search_objects`, `get_source`, `package_contents`, `ddic_type_info`, `transaction_info`, `table_contents` |
 | [ARC-1](https://github.com/arc-mcp/arc-1) | arc-mcp (Marian Zeis and contributors) | MIT | idea | `transport_diff`, `atc_quickfix`, `gateway_errors` |
-| [vibing-steampunk](https://github.com/oisee/vibing-steampunk) | oisee and contributors | MIT | idea | `co_change`, `api_release_state`, `jobs`, `application_log` |
+| [vibing-steampunk](https://github.com/oisee/vibing-steampunk) | oisee and contributors | MIT | idea | `co_change`, `api_release_state`, `source_search`, `enhancements`, `jobs`, `application_log` |
 | [ABAP Accelerator for Amazon Q Developer](https://github.com/aws-solutions-library-samples/guidance-for-deploying-sap-abap-accelerator-for-amazon-q-developer) | AWS Solutions Library Samples | MIT-0 | idea | all (core), `usage_stats` |
 | [An O(ND) Difference Algorithm and Its Variations (1986)](https://doi.org/10.1007/BF01840446) | Eugene W. Myers | published algorithm | algorithm | `transport_diff`, `atc_quickfix` |
 <!-- credits:end -->

package/dist/core/catalog.en.js

@@ -23,11 +23,14 @@ export const TOOLS_EN = {
     run_atc: "**Run ATC.** Runs the ABAP Test Cockpit on an object or a transport and lists numbered findings (priority, line, check, message) with SAP's P1/P2/P3 totals.",
     atc_quickfix: "**SAP-proposed fixes.** The fixes SAP offers (the same as Ctrl+1 in Eclipse) for an ATC finding or a line: create text symbol, extract constant, etc.",
     api_release_state: "**Is this API released? What is its successor?** Release state of an SAP object (class, function module/BAPI, table, CDS…) by contract C0–C4 and its released successor, read from the system itself.",
+    sap_notes: "**SAP notes in the system (SNOTE).** Whether a note is downloaded in this system, its implementation and processing status, version, component and title, per note or filtered by status/component; no SAP portal or S-user needed.",
     syntax_check: "**SAP syntax check.** SAP's real syntax check (not abaplint), also on code not saved yet.",
     run_unit_tests: "**Run ABAP Unit.** Runs the ABAP Unit tests of a class or program (harmless and short only) and returns the result per method, with each failure in detail.",
     search_objects: "**Search ABAP objects.** Searches repository objects by name (supports * wildcards).",
     get_source: "**Read ABAP source.** Reads the source of any object: program, include, class (and its includes), interface, function module (without knowing its group), CDS, table/structure, etc.",
     where_used: "**Where used.** Where-used list of an object: who references it, with package and owner.",
+    source_search: "**Search text in source code.** Searches a text or regex in the source of a package (with subpackages), a transport or a list of objects, and returns object, include, line and the matching line; reaches what where-used misses (dynamic calls, literals, Z code outside the reference index).",
+    enhancements: "**Enhancements and BAdIs.** Implementations of a BAdI (new and classic, active or not), source code enhancements implemented inside a program, class or function group (flagging those that overwrite standard code), or all enhancement implementations of a namespace by type.",
     object_versions: "**Object versions.** Version history of an object (date, author, transport).",
     package_contents: "**Package contents.** Objects of a development package grouped by type, with subpackages (TADIR/TDEVC, any release).",
     ddic_type_info: "**Data element, domain or table type.** Definition of a DDIC type: data element (domain, type, length, texts), domain (type, length, fixed values, value table) or table type (line type, key).",

package/dist/core/catalog.js

@@ -40,6 +40,7 @@ export const GROUPS = [
             { name: "run_atc", credits: ADT },
             { name: "atc_quickfix", credits: ["abapAdtApi", "arc1", "myers"] },
             { name: "api_release_state", credits: ["abapAdtApi", "vsp"] },
+            { name: "sap_notes", credits: ADT },
             { name: "syntax_check", credits: ["abapAdtApi", "abapFs"] },
             { name: "run_unit_tests", credits: ADT },
         ],
@@ -52,12 +53,14 @@ export const GROUPS = [
             { name: "search_objects", credits: ["abapAdtApi", "marioAdt"] },
             { name: "get_source", credits: ["abapAdtApi", "marioAdt"] },
             { name: "where_used", credits: ADT },
+            { name: "source_search", credits: ["abapAdtApi", "vsp"] },
             { name: "object_versions", credits: ADT },
             { name: "package_contents", credits: ["abapAdtApi", "marioAdt"] },
             { name: "ddic_type_info", credits: ["abapAdtApi", "marioAdt"] },
             { name: "transaction_info", credits: ["abapAdtApi", "marioAdt"] },
             { name: "function_modules", credits: ADT },
             { name: "text_elements", credits: ADT },
+            { name: "enhancements", credits: ["abapAdtApi", "vsp"] },
         ],
     },
     {

package/dist/core/concurrency.js

@@ -0,0 +1,13 @@
+/** Limita cuántas promesas corren a la vez (no saturar SAP). Conserva el orden de los resultados. */
+export async function pool(items, n, fn) {
+    const out = new Array(items.length);
+    let next = 0;
+    await Promise.all(Array.from({ length: Math.min(n, items.length) }, async () => {
+        while (next < items.length) {
+            const i = next++;
+            out[i] = await fn(items[i]);
+        }
+    }));
+    return out;
+}
+//# sourceMappingURL=concurrency.js.map

package/dist/core/packages.js

@@ -0,0 +1,26 @@
+import { sqlLiteral } from "./objects.js";
+/** Paquete y, si se pide, sus subpaquetes (hasta 5 niveles). `subs` son los hijos encontrados (directos si no es recursivo). */
+export async function packageTree(sap, root, recursive) {
+    const packages = [root];
+    const subs = [];
+    let frontier = [root];
+    for (let level = 0; level < (recursive ? 5 : 1) && frontier.length; level++) {
+        const r = await sap.query(`SELECT devclass FROM tdevc WHERE parentcl IN ( ${frontier.map(sqlLiteral).join(", ")} )`, 2000);
+        frontier = r.values.map((v) => v.DEVCLASS);
+        subs.push(...frontier);
+        if (recursive)
+            packages.push(...frontier);
+    }
+    return { packages, subs };
+}
+/**
+ * Objetos R3TR de esos paquetes (sin DEVC), ordenados por tipo y nombre. Sin los marcados como borrados
+ * (DELFLAG = 'X'): TADIR los conserva, pero ya no existen en el repositorio.
+ */
+export async function packageObjects(sap, packages, max, objectType) {
+    const typeFilter = objectType ? ` AND object = ${sqlLiteral(objectType.toUpperCase())}` : "";
+    const r = await sap.query(`SELECT devclass, pgmid, object, obj_name FROM tadir WHERE pgmid = 'R3TR' AND devclass IN ( ${packages.map(sqlLiteral).join(", ")} )` +
+        `${typeFilter} AND object <> 'DEVC' AND delflag = ' ' ORDER BY object, obj_name`, max);
+    return r.values;
+}
+//# sourceMappingURL=packages.js.map

package/dist/core/transport.js

@@ -45,6 +45,13 @@ export async function orderHeaders(sap, trkorrs) {
     }
     return out;
 }
+/** Entradas E071 de una orden y de todas sus tareas. */
+export async function orderEntries(sap, root) {
+    const tasks = await sap.query(`SELECT trkorr FROM e070 WHERE strkorr = ${sqlLiteral(root)}`, 500);
+    const ids = [root, ...tasks.values.map((v) => v.TRKORR)];
+    const rows = await sap.query(`SELECT pgmid, object, obj_name FROM e071 WHERE trkorr IN ( ${ids.map(sqlLiteral).join(", ")} )`, 5000);
+    return rows.values;
+}
 export function describeOrder(h) {
     return (`${h.trkorr} «${h.text}» · ${TRFUNCTION[h.trfunction] ?? h.trfunction} · ${TRSTATUS[h.trstatus] ?? h.trstatus} · ` +
         `${h.owner}` + (h.tarsystem ? ` · destino ${h.tarsystem}` : ""));

package/dist/tools/core/dumps.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { dataClassOf } from "../../core/datapolicy.js";
 import { ToolError } from "../../core/errors.js";
 import { decodeEntities, htmlToText } from "../../core/feeds.js";
 import { budget } from "../../core/output.js";
@@ -11,16 +12,87 @@ function headerField(d, label) {
     const m = d.text.match(new RegExp(`<b>${label}&nbsp;</b></td><td[^>]*>([\\s\\S]*?)</td>`));
     return m ? decode(m[1]).trim() : undefined;
 }
+const cat = (d, label) => d.categories.find((c) => c.label === label)?.term;
 function summary(d, i) {
-    const cat = (label) => d.categories.find((c) => c.label === label)?.term;
-    return (`${i}. ${headerField(d, "Date/Time")?.replace(" (System)", "") ?? "?"} · ${cat("ABAP runtime error") ?? "?"} · ` +
-        `${cat("Terminated ABAP program") ?? "?"} · ${d.author ?? "?"}\n   ${headerField(d, "Short Text") ?? ""}`);
+    return (`${i}. ${headerField(d, "Date/Time")?.replace(" (System)", "") ?? "?"} · ${cat(d, "ABAP runtime error") ?? "?"} · ` +
+        `${cat(d, "Terminated ABAP program") ?? "?"} · ${d.author ?? "?"}\n   ${headerField(d, "Short Text") ?? ""}`);
+}
+/**
+ * Cabecera de un dump tal como la guarda ST22 en SNAP_BEG.FLIST: secuencia de «id (2) + longitud (3) + valor».
+ * Solo trae metadatos (error, programa, include, línea, clase de excepción, ids), nunca valores de variables: esos
+ * están en SNAP, que sigue vetada. Ids verificados en un NW 7.50 real.
+ */
+export function parseFlist(flist) {
+    const out = {};
+    for (let i = 0; i + 5 <= flist.length;) {
+        const id = flist.slice(i, i + 2);
+        const len = Number(flist.slice(i + 2, i + 5));
+        if (!/^[A-Z0-9]{2}$/.test(id) || !Number.isInteger(len) || len < 0)
+            break;
+        out[id] = flist.slice(i + 5, i + 5 + len).trim();
+        i += 5 + len;
+    }
+    return out;
+}
+const GROUP_BY = ["error", "program", "error_program", "user", "day"];
+/** El tope de filas que se piden a SNAP_BEG: por encima, la respuesta dice que puede haber más. */
+export const GROUP_ROWS = 5000;
+function groupKey(by, r, h) {
+    const error = h.FC || "?";
+    const program = h.AP || "?";
+    switch (by) {
+        case "error": return error;
+        case "program": return program;
+        case "error_program": return `${error} · ${program}`;
+        case "user": return String(r.UNAME ?? "?");
+        case "day": return String(r.DATUM ?? "?");
+    }
+}
+export function groupDumps(rows, by) {
+    const groups = new Map();
+    for (const r of rows) {
+        const h = parseFlist(String(r.FLIST ?? ""));
+        const key = groupKey(by, r, h);
+        const at = `${r.DATUM} ${String(r.UZEIT ?? "").slice(0, 6)}`;
+        let g = groups.get(key);
+        if (!g) {
+            g = { key, count: 0, first: at, last: at, users: 0, userSet: new Set() };
+            groups.set(key, g);
+        }
+        g.count++;
+        if (at < g.first)
+            g.first = at;
+        if (at >= g.last) {
+            g.last = at;
+            if (h.AI)
+                g.where = `${h.AI}${h.AL ? ` L${h.AL}` : ""}`;
+        }
+        g.userSet.add(String(r.UNAME ?? ""));
+    }
+    return [...groups.values()]
+        .map(({ userSet, ...g }) => ({ ...g, users: userSet.size }))
+        .sort((a, b) => b.count - a.count || a.key.localeCompare(b.key));
+}
+const GROUP = z.object({
+    key: z.string(),
+    count: z.number().int(),
+    first: z.string().describe("AAAAMMDD hhmmss del primer dump del grupo en el periodo"),
+    last: z.string(),
+    users: z.number().int().describe("Usuarios distintos afectados"),
+    where: z.string().optional().describe("Include y línea del dump más reciente del grupo"),
+});
+function dayStamp(daysAgo, now = new Date()) {
+    const d = new Date(now.getTime() - daysAgo * 86_400_000);
+    return d.toISOString().slice(0, 10).replace(/-/g, "");
 }
 export default defineTool({
     name: "dumps",
     title: "Dumps (ST22)",
     description: "Lista los dumps de ejecución (ST22): fecha, error, programa, usuario y texto corto. Filtra por usuario y por " +
-        "texto (error o programa). Con detail=N devuelve el dump N completo (qué pasó, análisis, dónde terminó, fuente, pila).",
+        "texto (error o programa). Con detail=N devuelve el dump N completo (qué pasó, análisis, dónde terminó, fuente, pila). " +
+        "Con group_by (error, program, error_program, user, day) y days=N responde «los errores más frecuentes del periodo»: " +
+        "cuenta los dumps de los últimos N días agrupados, con primer y último caso, usuarios afectados y dónde terminó. " +
+        "La lista y el detalle salen del feed ADT (solo los más recientes); los grupos, de la cabecera de ST22 (SNAP_BEG).",
     access: "read",
     requires: { adt: ["/sap/bc/adt/runtime/dumps"] },
     input: {
@@ -28,29 +100,80 @@ export default defineTool({
         contains: z.string().optional().describe("Filtra por error o programa, p. ej. CALL_FUNCTION_NOT_FOUND o ZFI_REPORTE"),
         max: z.number().int().min(1).max(200).default(20),
         detail: z.number().int().min(1).optional().describe("Número de la lista para ver el dump completo"),
+        group_by: z.enum(GROUP_BY).optional().describe("Agrupar los dumps del periodo: por error, programa, error+programa, usuario o día"),
+        days: z.number().int().min(1).max(90).default(7).describe("Periodo hacia atrás para group_by (días)"),
     },
-    async run({ user, contains, max, detail }, { sap }) {
+    output: {
+        mode: z.enum(["list", "detail", "groups"]),
+        total: z.number().int().describe("Dumps considerados (feed leído o filas del periodo)"),
+        period_days: z.number().int().optional(),
+        since: z.string().optional().describe("AAAAMMDD desde el que se contó"),
+        truncated: z.boolean().optional().describe("true si el periodo tiene más dumps de los que se pudieron leer"),
+        group_by: z.enum(GROUP_BY).optional(),
+        groups: z.array(GROUP).optional(),
+        dumps: z.array(z.object({ n: z.number().int(), error: z.string(), program: z.string(), user: z.string() })).optional(),
+    },
+    async run({ user, contains, max, detail, group_by, days }, { sap, system }) {
+        if (group_by) {
+            if (group_by === "user" && dataClassOf(system) !== "test") {
+                throw new ToolError("POLICY", `En ${system.id} (datos ${dataClassOf(system)}) no se agrupa por usuario: es una columna personal. Agrupa por error o programa; el número de usuarios afectados sale igualmente.`);
+            }
+            const since = dayStamp(days);
+            const where = [`seqno = '000'`, `datum >= '${since}'`, ...(user ? [`uname = '${user.toUpperCase()}'`] : [])].join(" AND ");
+            const r = await sap.query(`SELECT datum, uzeit, uname, flist FROM snap_beg WHERE ${where} ORDER BY datum DESCENDING, uzeit DESCENDING`, GROUP_ROWS);
+            const needle = contains?.toUpperCase();
+            const rows = r.values.filter((row) => {
+                if (!needle)
+                    return true;
+                const h = parseFlist(String(row.FLIST ?? ""));
+                return (h.FC ?? "").toUpperCase().includes(needle) || (h.AP ?? "").toUpperCase().includes(needle);
+            });
+            const truncated = r.values.length >= GROUP_ROWS;
+            const groups = groupDumps(rows, group_by);
+            const shown = groups.slice(0, max);
+            const structured = { mode: "groups", total: rows.length, period_days: days, since, truncated, group_by, groups: shown };
+            if (!rows.length) {
+                return { text: `Sin dumps desde ${since} (${days} días)${user ? ` del usuario ${user}` : ""}${contains ? ` que casen con «${contains}»` : ""}: se consultó ST22 (SNAP_BEG) y no hay filas.`, structured };
+            }
+            const label = { error: "error", program: "programa", error_program: "error · programa", user: "usuario", day: "día" };
+            const lines = shown.map((g, i) => `${String(i + 1).padStart(3)}. ${String(g.count).padStart(5)}  ${g.key}  · ${g.users} usuario${g.users === 1 ? "" : "s"} · ${g.first.slice(0, 8)} → ${g.last.slice(0, 8)}${g.where ? ` · ${g.where}` : ""}`);
+            return {
+                text: `${rows.length} dumps desde ${since} (${days} días)${truncated ? ` — TOPE ALCANZADO (${GROUP_ROWS} filas): puede haber más; acota con days o contains` : ""}` +
+                    `, ${groups.length} grupos por ${label[group_by]} (se muestran ${shown.length})\n\n` +
+                    `  #  dumps  ${label[group_by]}\n${lines.join("\n")}\n\n` +
+                    `Siguiente: dumps(contains="<error o programa>") para ver los casos recientes y dumps(detail=N) para uno completo.`,
+                structured,
+            };
+        }
         const c = await sap.adt();
         const feed = await c.dumps(user ? `and( equals( user, ${user.toUpperCase()} ) )` : "");
         const needle = contains?.toUpperCase();
         const list = feed.dumps.filter((d) => !needle || d.categories.some((x) => x.term.toUpperCase().includes(needle)));
+        const asRow = (d, i) => ({ n: i + 1, error: cat(d, "ABAP runtime error") ?? "?", program: cat(d, "Terminated ABAP program") ?? "?", user: d.author ?? "?" });
         if (!list.length) {
-            return `El feed de dumps se leyó (${feed.dumps.length} en total) y ninguno casa${user ? ` con usuario ${user}` : ""}${contains ? ` y «${contains}»` : ""}.`;
+            return {
+                text: `El feed de dumps se leyó (${feed.dumps.length} en total) y ninguno casa${user ? ` con usuario ${user}` : ""}${contains ? ` y «${contains}»` : ""}. Para un periodo largo usa group_by.`,
+                structured: { mode: "list", total: feed.dumps.length, dumps: [] },
+            };
         }
         if (detail) {
             const d = list[detail - 1];
             if (!d)
                 throw new ToolError("INPUT", `Solo hay ${list.length} dumps en la lista.`);
+            const structured = { mode: "detail", total: list.length, dumps: [asRow(d, detail - 1)] };
             const self = d.links.find((l) => l.rel === "self")?.href.replace(/^adt:\/\/[^/]+/, "");
             if (!self)
-                return budget(stripHtml(d.text));
+                return { text: budget(stripHtml(d.text)), structured };
             // El recurso ofrece HTML (dump completo) o un XML índice; text/plain da 406.
             const r = await c.httpClient.request(self, { headers: { Accept: "text/html" } });
-            return budget(`${summary(d, detail)}\n\n${stripHtml(String(r.body))}`, undefined, "El dump completo está en ST22.");
+            return { text: budget(`${summary(d, detail)}\n\n${stripHtml(String(r.body))}`, undefined, "El dump completo está en ST22."), structured };
         }
         const shown = list.slice(0, max);
-        return (`${list.length} dumps${needle || user ? " que casan" : ""} (se muestran ${shown.length}; el feed trae los más recientes)\n\n` +
-            shown.map((d, i) => summary(d, i + 1)).join("\n"));
+        return {
+            text: `${list.length} dumps${needle || user ? " que casan" : ""} (se muestran ${shown.length}; el feed trae solo los más recientes: para un periodo usa group_by)\n\n` +
+                shown.map((d, i) => summary(d, i + 1)).join("\n"),
+            structured: { mode: "list", total: list.length, dumps: shown.map(asRow) },
+        };
     },
 });
 //# sourceMappingURL=dumps.js.map

package/dist/tools/core/enhancements.js

@@ -0,0 +1,135 @@
+import { z } from "zod";
+import { rowCap } from "../../core/datapolicy.js";
+import { ToolError } from "../../core/errors.js";
+import { sqlLiteral } from "../../core/objects.js";
+import { tsv } from "../../core/output.js";
+import { defineTool } from "../../core/tool.js";
+/**
+ * Ampliaciones del sistema por SQL de diccionario (valen en 7.50 y S/4):
+ * - BAdI nuevas (framework de ampliaciones): BADIIMPL_ENH; clásicas: SXC_EXIT + SXC_ATTR.
+ * - Ampliaciones en código (puntos y secciones implícitos o explícitos): ENHINCINX, por programa principal.
+ * - Implementaciones de ampliación: ENHHEADER.
+ * Los significados vienen del diccionario (ENHMODE, ENHBOOLEAN, ACTIVEFLAG), verificados en un 7.50.
+ */
+const ENHMODE = { S: "estática", D: "dinámica" };
+/** ENHTOOLTYPE no tiene valores fijos en el diccionario: se muestra el código y, si se conoce, qué es. */
+const TOOL = {
+    HOOK_IMPL: "ampliación de código (punto o sección)",
+    BADI_IMPL: "implementación de BAdI",
+    CLASENH: "ampliación de clase",
+    INTFENH: "ampliación de interfaz",
+    FUGRENH: "ampliación de grupo de funciones",
+    WDYENH: "ampliación Web Dynpro",
+};
+const tool = (t) => (TOOL[t] ? `${t} (${TOOL[t]})` : t);
+/** Nombre del programa principal que usa ENHINCINX: clase → NOMBRE====…CP (32), grupo → SAPL<grupo>. */
+export function mainProgram(name, type) {
+    const n = name.trim().toUpperCase();
+    if (type === "PROG")
+        return n;
+    if (type === "CLAS")
+        return `${n.padEnd(30, "=")}CP`;
+    const m = /^(\/[^/]+\/)(.+)$/.exec(n);
+    return m ? `${m[1]}SAPL${m[2]}` : `SAPL${n}`;
+}
+const NAME = /^[A-Z0-9_/]{1,40}$/i;
+/** Propias del cliente primero: Z, Y y espacios de nombres que no son de SAP no se distinguen aquí; Z/Y sí. */
+const isCustom = (n) => /^[ZY]/i.test(n);
+export default defineTool({
+    name: "enhancements",
+    title: "Ampliaciones y BAdI",
+    description: "Qué ampliaciones hay y dónde. badi=NOMBRE: implementaciones de esa BAdI, nuevas y clásicas, activas o no. " +
+        "program + program_type (PROG, CLAS, FUGR): ampliaciones de código (puntos y secciones implícitos o explícitos) " +
+        "implementadas dentro de ese programa, clase o grupo — lo que cambia el comportamiento de un estándar sin tocar " +
+        "su código. prefix (p. ej. Z): implementaciones de ampliación de ese espacio de nombres, por tipo. Solo lectura.",
+    access: "read",
+    input: {
+        badi: z.string().regex(NAME).optional().describe("Definición de BAdI, p. ej. MB_MIGO_BADI"),
+        program: z.string().regex(NAME).optional().describe("Programa, clase o grupo de funciones ampliado, p. ej. SAPMV45A"),
+        program_type: z.enum(["PROG", "CLAS", "FUGR"]).default("PROG"),
+        prefix: z.string().regex(/^[A-Z0-9_/]{1,20}$/i).optional().describe("Implementaciones cuyo nombre empieza así, p. ej. Z o ZSD"),
+        tool_type: z.string().regex(/^[A-Z_]{3,20}$/i).optional().describe("Con prefix: filtrar por tipo, p. ej. BADI_IMPL o HOOK_IMPL"),
+        max: z.number().int().min(1).max(2000).default(200),
+    },
+    output: {
+        mode: z.enum(["badi", "program", "prefix"]),
+        target: z.string(),
+        rows: z.array(z.record(z.union([z.string(), z.number(), z.boolean()]))),
+        total: z.number().int(),
+        truncated: z.boolean(),
+    },
+    async run({ badi, program, program_type, prefix, tool_type, max }, { sap, system }) {
+        if ([badi, program, prefix].filter(Boolean).length !== 1)
+            throw new ToolError("INPUT", "Indica exactamente uno: badi, program o prefix.");
+        const cap = Math.min(max, rowCap(system));
+        if (badi) {
+            const b = badi.toUpperCase();
+            const kernel = await sap.query(`SELECT enhname, badi_impl, active, spotname FROM badiimpl_enh WHERE badi_name = ${sqlLiteral(b)}`, 2000);
+            const classic = await sap.query(`SELECT imp_name FROM sxc_exit WHERE exit_name = ${sqlLiteral(b)}`, 2000);
+            const names = classic.values.map((v) => String(v.IMP_NAME).trim());
+            const attr = names.length ? await sap.query(`SELECT imp_name, active FROM sxc_attr WHERE imp_name IN ( ${names.map(sqlLiteral).join(", ")} )`, 2000) : { values: [] };
+            const activeClassic = new Map(attr.values.map((v) => [String(v.IMP_NAME).trim(), v.ACTIVE === "X"]));
+            // Una BAdI clásica migrada aparece en las dos tablas: se muestra una vez, como nueva.
+            const kernelImpls = new Set(kernel.values.map((v) => String(v.BADI_IMPL).trim()));
+            const rows = [
+                ...kernel.values.map((v) => ({ implementation: String(v.BADI_IMPL).trim(), kind: "nueva", enhancement: String(v.ENHNAME).trim(), spot: String(v.SPOTNAME ?? "").trim(), active: v.ACTIVE === "X" })),
+                ...names.filter((n) => !kernelImpls.has(n)).map((n) => ({ implementation: n, kind: "clásica", enhancement: "", spot: "", active: activeClassic.get(n) ?? false })),
+            ].sort((a, b2) => Number(isCustom(b2.implementation)) - Number(isCustom(a.implementation)) || Number(b2.active) - Number(a.active) || a.implementation.localeCompare(b2.implementation));
+            const shown = rows.slice(0, cap);
+            const structured = { mode: "badi", target: b, rows: shown, total: rows.length, truncated: rows.length > cap };
+            if (!rows.length)
+                return { text: `La BAdI ${b} no tiene implementaciones en este sistema (se consultaron BADIIMPL_ENH y SXC_EXIT).`, structured };
+            const act = rows.filter((r) => r.active).length;
+            return {
+                text: `BAdI ${b}: ${rows.length} implementaciones, ${act} activas, ${rows.filter((r) => isCustom(r.implementation)).length} propias (Z/Y, primero)` +
+                    `${rows.length > cap ? ` (se muestran ${cap})` : ""}\n\n` +
+                    tsv(["implementación", "tipo", "activa", "ampliación", "spot"], shown.map((r) => [r.implementation, r.kind, r.active ? "sí" : "NO", r.enhancement, r.spot])),
+                structured,
+            };
+        }
+        if (program) {
+            const p = mainProgram(program, program_type);
+            const r = await sap.query(`SELECT enhname, version, enhmode, overwrite FROM enhincinx WHERE programname = ${sqlLiteral(p)} ORDER BY enhname`, 5000);
+            const by = new Map();
+            for (const v of r.values) {
+                const k = String(v.ENHNAME).trim();
+                const cur = by.get(k) ?? { enhancement: k, mode: ENHMODE[String(v.ENHMODE)] ?? String(v.ENHMODE), active: false, overwrite: false, places: 0 };
+                cur.places++;
+                if (v.VERSION === "A")
+                    cur.active = true;
+                if (v.OVERWRITE === "X")
+                    cur.overwrite = true;
+                by.set(k, cur);
+            }
+            const rows = [...by.values()].sort((a, b2) => a.enhancement.localeCompare(b2.enhancement));
+            const shown = rows.slice(0, cap);
+            const structured = { mode: "program", target: p, rows: shown, total: rows.length, truncated: rows.length > cap };
+            if (!rows.length)
+                return { text: `${program.toUpperCase()} (${p}) no tiene ampliaciones de código implementadas (se consultó ENHINCINX).`, structured };
+            const over = rows.filter((x) => x.overwrite).length;
+            return {
+                text: `${program.toUpperCase()} (${p}): ${rows.length} implementaciones de ampliación en su código` +
+                    `${over ? ` — ${over} SUSTITUYEN código estándar (overwrite)` : ""}${rows.length > cap ? ` (se muestran ${cap})` : ""}\n\n` +
+                    tsv(["ampliación", "modo", "activa", "sustituye", "lugares"], shown.map((x) => [x.enhancement, x.mode, x.active ? "sí" : "solo inactiva", x.overwrite ? "SÍ" : "", x.places])),
+                structured,
+            };
+        }
+        const pre = prefix.toUpperCase();
+        const typeFilter = tool_type ? ` AND enhtooltype = ${sqlLiteral(tool_type.toUpperCase())}` : "";
+        const where = `WHERE enhname LIKE ${sqlLiteral(`${pre}%`)} AND version = 'A'${typeFilter}`;
+        const counts = await sap.query(`SELECT enhtooltype, COUNT(*) AS n FROM enhheader ${where} GROUP BY enhtooltype`, 50);
+        const total = counts.values.reduce((s, v) => s + Number(v.N), 0);
+        const r = await sap.query(`SELECT enhname, enhtooltype FROM enhheader ${where} ORDER BY enhname`, cap);
+        const rows = r.values.map((v) => ({ enhancement: String(v.ENHNAME).trim(), type: String(v.ENHTOOLTYPE).trim() }));
+        const structured = { mode: "prefix", target: pre, rows, total, truncated: total > rows.length };
+        if (!total)
+            return { text: `No hay implementaciones de ampliación activas que empiecen por ${pre}${tool_type ? ` de tipo ${tool_type}` : ""}.`, structured };
+        const summary = counts.values.map((v) => `${tool(String(v.ENHTOOLTYPE).trim())}: ${Number(v.N)}`).join(" · ");
+        return {
+            text: `${total} implementaciones de ampliación activas que empiezan por ${pre}${total > rows.length ? ` (se muestran ${rows.length})` : ""}\n${summary}\n\n` +
+                tsv(["ampliación", "tipo"], rows.map((x) => [x.enhancement, x.type])),
+            structured,
+        };
+    },
+});
+//# sourceMappingURL=enhancements.js.map

package/dist/tools/core/package_contents.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { ToolError } from "../../core/errors.js";
 import { sqlLiteral } from "../../core/objects.js";
+import { packageObjects, packageTree } from "../../core/packages.js";
 import { defineTool } from "../../core/tool.js";
 export default defineTool({
     name: "package_contents",
@@ -21,20 +22,8 @@ export default defineTool({
         if (!h)
             throw new ToolError("NOT_FOUND", `El paquete ${root} no existe en este sistema.`);
         const txt = await sap.query(`SELECT ctext FROM tdevct WHERE devclass = ${sqlLiteral(root)}`, 1);
-        // Árbol de subpaquetes (hasta 5 niveles si es recursivo).
-        const packages = [root];
-        const subs = [];
-        let frontier = [root];
-        for (let level = 0; level < (recursive ? 5 : 1) && frontier.length; level++) {
-            const r = await sap.query(`SELECT devclass FROM tdevc WHERE parentcl IN ( ${frontier.map(sqlLiteral).join(", ")} )`, 2000);
-            frontier = r.values.map((v) => v.DEVCLASS);
-            subs.push(...frontier);
-            if (recursive)
-                packages.push(...frontier);
-        }
-        const typeFilter = object_type ? ` AND object = ${sqlLiteral(object_type.toUpperCase())}` : "";
-        const objs = await sap.query(`SELECT devclass, object, obj_name FROM tadir WHERE pgmid = 'R3TR' AND devclass IN ( ${packages.map(sqlLiteral).join(", ")} )` +
-            `${typeFilter} AND object <> 'DEVC' ORDER BY object, obj_name`, max_objects);
+        const { packages, subs } = await packageTree(sap, root, recursive);
+        const objs = { values: await packageObjects(sap, packages, max_objects, object_type) };
         const byType = new Map();
         for (const o of objs.values) {
             const label = recursive && o.DEVCLASS !== root ? `${o.OBJ_NAME} [${o.DEVCLASS}]` : o.OBJ_NAME;

package/dist/tools/core/sap_notes.js

@@ -0,0 +1,148 @@
+import { z } from "zod";
+import { dataClassOf, rowCap } from "../../core/datapolicy.js";
+import { ToolError } from "../../core/errors.js";
+import { sqlLiteral } from "../../core/objects.js";
+import { tsv } from "../../core/output.js";
+import { defineTool } from "../../core/tool.js";
+/**
+ * Estado de las notas SAP en ESTE sistema (lo que muestra SNOTE), leído de las tablas de la herramienta de notas:
+ * CWBNTCUST (estado por nota), CWBNTHEAD (versión y componente) y CWBNTSTXT (título). No consulta el portal de SAP
+ * ni necesita S-user: solo sabe de las notas descargadas en el sistema. Los códigos de estado no son valores fijos
+ * del diccionario; su significado sale de las constantes de SAP (IF_SCWN_NA_CONSTANTS), verificadas en un 7.50.
+ */
+/** CWBNTCUST-PRSTATUS, «Implementation State». */
+export const IMPL_STATE = {
+    E: "implementada completamente",
+    U: "implementada de forma incompleta",
+    V: "implementada una versión anterior",
+    N: "se puede implementar (no implementada)",
+    O: "obsoleta",
+    "-": "no se puede implementar (sin instrucción de corrección válida)",
+    "": "sin determinar",
+};
+/** CWBNTCUST-NTSTATUS, «Processing Status». */
+export const PROC_STATE = { N: "nueva", I: "en tratamiento", A: "terminada", R: "no relevante" };
+const describe = (map, code) => map[code.trim()] ?? `código «${code}» desconocido`;
+const noteKey = (n) => String(Number(n));
+/** Una consulta por tramo: un IN con miles de literales supera lo que acepta la vista previa de datos ADT. */
+export async function inChunks(sap, sql, keys, size = 200) {
+    const out = [];
+    for (let i = 0; i < keys.length; i += size)
+        out.push(...(await sap.query(sql(keys.slice(i, i + size).map(sqlLiteral).join(", ")), 5000)).values);
+    return out;
+}
+export async function noteDetails(sap, notes) {
+    const heads = { values: await inChunks(sap, (l) => `SELECT numm, versno, themk FROM cwbnthead WHERE numm IN ( ${l} )`, notes) };
+    const latest = new Map();
+    for (const h of heads.values) {
+        const k = noteKey(h.NUMM);
+        const v = Number(h.VERSNO);
+        if (!latest.has(k) || v > latest.get(k).version)
+            latest.set(k, { version: v, component: String(h.THEMK ?? "").trim() });
+    }
+    const texts = { values: await inChunks(sap, (l) => `SELECT numm, versno, langu, stext FROM cwbntstxt WHERE numm IN ( ${l} ) AND ( langu = 'S' OR langu = 'E' )`, notes) };
+    const title = new Map();
+    for (const t of texts.values) {
+        const k = noteKey(t.NUMM);
+        const cand = { v: Number(t.VERSNO), lang: String(t.LANGU), text: String(t.STEXT ?? "").trim() };
+        const cur = title.get(k);
+        // Versión más alta; a igual versión, español antes que inglés.
+        if (!cur || cand.v > cur.v || (cand.v === cur.v && cand.lang === "S" && cur.lang !== "S"))
+            title.set(k, cand);
+    }
+    return { latest, title };
+}
+const NOTE = z.object({
+    note: z.string(),
+    downloaded: z.boolean().describe("false = la nota no está en este sistema (nunca se descargó con SNOTE)"),
+    implementation: z.string().optional(),
+    implementation_code: z.string().optional(),
+    processing: z.string().optional(),
+    version: z.number().int().optional(),
+    component: z.string().optional(),
+    title: z.string().optional(),
+    processor: z.string().optional().describe("Usuario que la trató (solo en sistemas con datos de prueba)"),
+});
+export default defineTool({
+    name: "sap_notes",
+    title: "Notas SAP en el sistema (SNOTE)",
+    description: "Estado de notas SAP en este sistema, como en SNOTE: si está descargada, estado de implementación (completa, " +
+        "incompleta, versión anterior, se puede implementar, obsoleta, no se puede implementar), estado de tratamiento, " +
+        "versión, componente y título. Con notes=[…] responde por notas concretas (p. ej. «¿está la 2198647 en PRD?»); " +
+        "sin notas, lista las del estado pedido. Solo conoce las notas descargadas en el sistema: no consulta el portal.",
+    access: "read",
+    input: {
+        notes: z.array(z.string().regex(/^\d{1,10}$/, "número de nota: solo dígitos")).max(200).optional(),
+        implementation: z
+            .array(z.enum(["E", "U", "V", "N", "O", "-"]))
+            .optional()
+            .describe("Sin notes: filtrar por estado de implementación (E completa, U incompleta, V versión anterior, N se puede implementar, O obsoleta, - no se puede)"),
+        component: z.string().regex(/^[A-Z0-9-]{2,24}$/i).optional().describe("Sin notes: prefijo de componente, p. ej. SD-BF o MM-PUR"),
+        max: z.number().int().min(1).max(1000).default(100),
+    },
+    output: { notes: z.array(NOTE), total: z.number().int(), truncated: z.boolean() },
+    async run({ notes, implementation, component, max }, { sap, system }) {
+        const showUser = dataClassOf(system) === "test";
+        const cap = Math.min(max, rowCap(system));
+        let custRows;
+        let counted;
+        if (notes?.length) {
+            const r = await sap.query(`SELECT numm, ntstatus, prstatus, cwbuser FROM cwbntcust WHERE numm IN ( ${notes.map(sqlLiteral).join(", ")} )`, 1000);
+            custRows = r.values;
+        }
+        else if (component) {
+            // El componente está en la cabecera: se filtra ahí y luego se trae el estado de esas notas, por tramos.
+            const h = await sap.query(`SELECT DISTINCT numm FROM cwbnthead WHERE themk LIKE ${sqlLiteral(`${component.toUpperCase()}%`)}`, 5000);
+            const ids = h.values.map((v) => noteKey(v.NUMM));
+            const impl = implementation?.length ? ` AND prstatus IN ( ${implementation.map(sqlLiteral).join(", ")} )` : "";
+            custRows = await inChunks(sap, (l) => `SELECT numm, ntstatus, prstatus, cwbuser FROM cwbntcust WHERE numm IN ( ${l} )${impl}`, ids);
+            custRows.sort((a, b) => Number(b.NUMM) - Number(a.NUMM));
+        }
+        else {
+            if (!implementation?.length)
+                throw new ToolError("INPUT", "Indica notes, o un filtro: implementation y/o component.");
+            const where = `WHERE prstatus IN ( ${implementation.map(sqlLiteral).join(", ")} )`;
+            const r = await sap.query(`SELECT numm, ntstatus, prstatus, cwbuser FROM cwbntcust ${where} ORDER BY numm DESCENDING`, cap + 1);
+            custRows = r.values;
+            counted = Number((await sap.query(`SELECT COUNT(*) AS n FROM cwbntcust ${where}`, 1)).values[0]?.N ?? custRows.length);
+        }
+        // Sin notas concretas solo hace falta el detalle de las que se van a mostrar.
+        const shownRows = notes?.length ? custRows : custRows.slice(0, cap);
+        const keys = [...new Set([...(notes ?? []).map(noteKey), ...shownRows.map((c) => noteKey(c.NUMM))])];
+        const { latest, title } = keys.length ? await noteDetails(sap, keys) : { latest: new Map(), title: new Map() };
+        const byNote = new Map(custRows.map((c) => [noteKey(c.NUMM), c]));
+        let rows = (notes?.length ? notes.map(noteKey) : [...byNote.keys()]).map((k) => {
+            const c = byNote.get(k);
+            const h = latest.get(k);
+            if (!c && !h)
+                return { note: k, downloaded: false };
+            const impl = String(c?.PRSTATUS ?? "").trim();
+            return {
+                note: k,
+                downloaded: true,
+                implementation: c ? describe(IMPL_STATE, impl) : "sin estado en SNOTE",
+                implementation_code: c ? impl || " " : undefined,
+                processing: c ? describe(PROC_STATE, String(c.NTSTATUS ?? "")) : undefined,
+                version: h?.version,
+                component: h?.component,
+                title: title.get(k)?.text,
+                ...(showUser && c?.CWBUSER ? { processor: String(c.CWBUSER).trim() } : {}),
+            };
+        });
+        const total = notes?.length ? rows.length : (counted ?? custRows.length);
+        const truncated = !notes?.length && total > cap;
+        rows = rows.slice(0, notes?.length ? rows.length : cap);
+        const structured = { notes: rows, total, truncated };
+        if (!rows.length)
+            return { text: "La consulta se hizo y ninguna nota de este sistema cumple el filtro.", structured };
+        const header = ["nota", "descargada", "implementación", "tratamiento", "versión", "componente", "título", ...(showUser ? ["tratada por"] : [])];
+        const table = tsv(header, rows.map((r) => [r.note, r.downloaded ? "sí" : "NO", r.implementation ?? "—", r.processing ?? "—", r.version ?? "", r.component ?? "", r.title ?? "", ...(showUser ? [r.processor ?? ""] : [])]));
+        const missing = rows.filter((r) => !r.downloaded).map((r) => r.note);
+        return {
+            text: `${rows.length} notas${truncated ? ` (TOPE: hay ${total}; sube max o afina el filtro)` : ""}\n\n${table}` +
+                (missing.length ? `\n\nNo descargadas en este sistema: ${missing.join(", ")}. Que no esté no significa que no aplique: SNOTE solo conoce lo descargado.` : ""),
+            structured,
+        };
+    },
+});
+//# sourceMappingURL=sap_notes.js.map

package/dist/tools/core/source_search.js

@@ -0,0 +1,188 @@
+import { z } from "zod";
+import { ADTClient } from "abap-adt-api";
+import { pool } from "../../core/concurrency.js";
+import { normalizeError, ToolError } from "../../core/errors.js";
+import { resolveByTypePrefix, sqlLiteral } from "../../core/objects.js";
+import { packageObjects, packageTree } from "../../core/packages.js";
+import { assertTrkorr } from "../../core/policy.js";
+import { sourceObjectsOf } from "../../core/revisions.js";
+import { defineTool } from "../../core/tool.js";
+import { orderEntries, orderHeaders } from "../../core/transport.js";
+/**
+ * Búsqueda de texto en el código fuente de un alcance acotado (paquete, orden u objetos). ADT tiene un endpoint de
+ * búsqueda de texto (`informationsystem/textsearch`), pero en NW 7.50 no existe: responde 404 y no figura en el
+ * discovery. Así que se leen las fuentes del alcance y se busca aquí. Sirve donde where_used no llega: el índice de
+ * referencias de un sistema convertido puede no cubrir el código Z.
+ */
+const MAX_PATTERN = 200;
+const MAX_LINE = 200;
+/** Programa principal e includes de un grupo de funciones, con namespace: /DZ/GRP → /DZ/SAPLGRP y /DZ/LGRP. */
+export function groupNames(group) {
+    const g = group.trim().toUpperCase();
+    const m = /^(\/[^/]+\/)(.+)$/.exec(g);
+    return m ? { main: `${m[1]}SAPL${m[2]}`, includePrefix: `${m[1]}L${m[2]}` } : { main: `SAPL${g}`, includePrefix: `L${g}` };
+}
+/**
+ * Un grupo de funciones se busca en sus módulos (TFDIR) y en sus includes propios (TOP, F, O, I…), no en los U (son
+ * los módulos) ni en los generados con «$». ADT tipa esos includes como FUGR/I, no PROG/I (verificado en 7.50).
+ */
+async function expandGroup(sap, group) {
+    const { main, includePrefix } = groupNames(group);
+    const fms = await sap.query(`SELECT funcname FROM tfdir WHERE pname = ${sqlLiteral(main)}`, 500);
+    const incs = await sap.query(`SELECT name FROM trdir WHERE name LIKE ${sqlLiteral(`${includePrefix}%`)} AND name NOT LIKE ${sqlLiteral(`${includePrefix}U%`)}`, 500);
+    return [
+        ...fms.values.map((v) => ({ name: String(v.FUNCNAME).trim(), types: ["FUGR/FF"], from: [`R3TR FUGR ${group}`] })),
+        ...incs.values
+            .map((v) => String(v.NAME).trim())
+            .filter((n) => !n.includes("$"))
+            .map((name) => ({ name, types: ["FUGR/I", "PROG/"], from: [`R3TR FUGR ${group}`] })),
+    ];
+}
+async function scopeRefs(sap, a, max) {
+    let rows;
+    let label;
+    if (a.package) {
+        const root = a.package.trim().toUpperCase();
+        const { packages } = await packageTree(sap, root, a.include_subpackages);
+        rows = await packageObjects(sap, packages, 5000);
+        label = `paquete ${root}${a.include_subpackages && packages.length > 1 ? ` y ${packages.length - 1} subpaquetes` : ""}`;
+    }
+    else if (a.transport) {
+        const tr = assertTrkorr(a.transport);
+        const head = (await orderHeaders(sap, [tr])).get(tr);
+        if (!head)
+            throw new ToolError("NOT_FOUND", `La orden ${tr} no existe en este sistema.`);
+        const root = head.parent || tr;
+        rows = await orderEntries(sap, root);
+        label = `orden ${root}${root !== tr ? ` (pediste la tarea ${tr})` : ""}`;
+    }
+    else {
+        // Lista explícita: cada nombre se resuelve con cualquier tipo con fuente.
+        const refs = a.objects.map((n) => ({ name: n.trim().toUpperCase(), types: ["PROG/", "CLAS/", "INTF/", "FUGR/FF", "DDLS/"], from: ["objects"] }));
+        return { refs: refs.slice(0, max), total: refs.length, label: `${refs.length} objetos indicados` };
+    }
+    const { source, other } = sourceObjectsOf(rows);
+    const groups = other.filter((o) => o.startsWith("R3TR FUGR ")).map((o) => o.slice("R3TR FUGR ".length));
+    const refs = [...source];
+    for (const g of groups)
+        refs.push(...(await expandGroup(sap, g)));
+    return { refs: refs.slice(0, max), total: refs.length, label };
+}
+/** Fuentes de un objeto: una sola, salvo clases (main y sus includes locales, los que existan). */
+async function sourcesOf(c, uri, type) {
+    if (!type.startsWith("CLAS")) {
+        const url = ADTClient.isMainInclude(uri) ? uri : `${uri}/source/main`;
+        return [{ include: "main", text: await c.getObjectSource(url) }];
+    }
+    const includes = ADTClient.classIncludes((await c.objectStructure(uri)));
+    const out = [];
+    for (const inc of ["main", "definitions", "implementations", "testclasses"]) {
+        const url = includes.get(inc);
+        if (url)
+            out.push({ include: inc, text: await c.getObjectSource(url) });
+    }
+    return out;
+}
+function matcher(text, regex) {
+    if (text.length > MAX_PATTERN)
+        throw new ToolError("INPUT", `El patrón tiene ${text.length} caracteres; el máximo es ${MAX_PATTERN}.`);
+    if (!regex) {
+        const needle = text.toUpperCase();
+        return (line) => line.toUpperCase().includes(needle);
+    }
+    let re;
+    try {
+        re = new RegExp(text, "i");
+    }
+    catch (e) {
+        throw new ToolError("INPUT", `Expresión regular inválida: ${e.message}`);
+    }
+    return (line) => re.test(line);
+}
+const isComment = (line) => line.startsWith("*") || line.trimStart().startsWith('"');
+const HIT = z.object({ object: z.string(), type: z.string(), include: z.string(), line: z.number().int(), text: z.string() });
+export default defineTool({
+    name: "source_search",
+    title: "Buscar texto en el código",
+    description: "Busca un texto (o una expresión regular) en el código fuente de un paquete (con subpaquetes), de una orden de " +
+        "transporte o de una lista de objetos, y devuelve objeto, include, línea y la línea encontrada. Sirve donde " +
+        "where_used no llega: llamadas dinámicas, literales, código Z que el índice de referencias no cubre. Lee cada " +
+        "fuente, así que exige un alcance y tiene tope de objetos; los objetos que no se pudieron leer se listan aparte.",
+    access: "read",
+    timeoutMs: 180_000,
+    input: {
+        text: z.string().min(2).describe("Texto a buscar (sin distinguir mayúsculas), p. ej. RV_FLOW o 'CALL FUNCTION'"),
+        regex: z.boolean().default(false).describe("Tratar text como expresión regular (máx. 200 caracteres)"),
+        package: z.string().optional().describe("Alcance: paquete de desarrollo"),
+        include_subpackages: z.boolean().default(true),
+        transport: z.string().optional().describe("Alcance: orden (o tarea) de transporte"),
+        objects: z.array(z.string().min(1)).max(200).optional().describe("Alcance: lista de objetos por nombre"),
+        ignore_comments: z.boolean().default(false).describe("No contar líneas de comentario"),
+        // ~0,8 s por objeto medido en un 7.50 con 4 lecturas en paralelo: 150 objetos caben en el tiempo máximo de la tool.
+        max_objects: z.number().int().min(1).max(1000).default(150),
+        max_hits: z.number().int().min(1).max(2000).default(300),
+    },
+    output: {
+        scope: z.string(),
+        objects_in_scope: z.number().int(),
+        scanned: z.number().int().describe("Objetos leídos"),
+        truncated: z.boolean().describe("true si el alcance tenía más objetos que max_objects o más coincidencias que max_hits"),
+        hits: z.array(HIT),
+        skipped: z.array(z.object({ object: z.string(), reason: z.string() })).describe("Objetos que no se pudieron leer"),
+    },
+    async run(a, ctx) {
+        const scopes = [a.package, a.transport, a.objects?.length ? "x" : undefined].filter(Boolean).length;
+        if (scopes !== 1) {
+            throw new ToolError("INPUT", "Indica exactamente un alcance: package, transport u objects. Buscar en todo el repositorio no es viable leyendo fuentes.");
+        }
+        const match = matcher(a.text, a.regex);
+        const { sap } = ctx;
+        const { refs, total, label } = await scopeRefs(sap, a, a.max_objects);
+        const c = await sap.adt();
+        const hits = [];
+        const skipped = [];
+        let done = 0;
+        let scanned = 0;
+        ctx.progress?.(`Leyendo ${refs.length} objetos de ${label}…`, 0, refs.length);
+        await pool(refs, 4, async (ref) => {
+            ctx.signal?.throwIfAborted();
+            try {
+                const res = await resolveByTypePrefix(c, ref.name, ref.types);
+                if (!res) {
+                    skipped.push({ object: ref.name, reason: "no se encontró con un tipo con fuente" });
+                    return;
+                }
+                for (const src of await sourcesOf(c, res.uri, res.type)) {
+                    src.text.split(/\r?\n/).forEach((line, i) => {
+                        if (hits.length >= a.max_hits || (a.ignore_comments && isComment(line)) || !match(line))
+                            return;
+                        hits.push({ object: ref.name, type: res.type, include: src.include, line: i + 1, text: line.trim().slice(0, MAX_LINE) });
+                    });
+                }
+                scanned++;
+            }
+            catch (e) {
+                const te = normalizeError(e);
+                if (te.kind === "NETWORK" || te.kind === "AUTH" || te.kind === "CANCELLED")
+                    throw te;
+                skipped.push({ object: ref.name, reason: `${te.kind}: ${te.message.slice(0, 120)}` });
+            }
+            finally {
+                ctx.progress?.(`${++done} de ${refs.length} objetos leídos`, done, refs.length);
+            }
+        });
+        hits.sort((x, y) => x.object.localeCompare(y.object) || x.include.localeCompare(y.include) || x.line - y.line);
+        const truncated = total > refs.length || hits.length >= a.max_hits;
+        const structured = { scope: label, objects_in_scope: total, scanned, truncated, hits, skipped };
+        const head = `«${a.text}»${a.regex ? " (regex)" : ""} en ${label}: ${hits.length} coincidencias en ${new Set(hits.map((h) => h.object)).size} objetos · ` +
+            `${scanned} de ${total} objetos leídos` +
+            (total > refs.length ? ` — TOPE ALCANZADO: ${total - refs.length} objetos sin leer (sube max_objects o acota el alcance)` : "") +
+            (hits.length >= a.max_hits ? ` — tope de ${a.max_hits} coincidencias: puede haber más` : "");
+        const lines = hits.map((h) => `${h.object}${h.include !== "main" ? ` (${h.include})` : ""} L${h.line}: ${h.text}`);
+        const skip = skipped.length ? `\n\nNo se pudieron leer (${skipped.length}):\n${skipped.map((s) => `  ${s.object}: ${s.reason}`).join("\n")}` : "";
+        if (!hits.length)
+            return { text: `${head}.\nSe leyó el código y no aparece.${skip}`, structured };
+        return { text: `${head}\n\n${lines.join("\n")}${skip}`, structured };
+    },
+});
+//# sourceMappingURL=source_search.js.map

package/dist/tools/core/transport_diff.js

@@ -3,23 +3,12 @@ import { diffLines, unified } from "../../core/diff.js";
 import { normalizeError, ToolError } from "../../core/errors.js";
 import { resolveByTypePrefix, sqlLiteral } from "../../core/objects.js";
 import { assertTrkorr } from "../../core/policy.js";
+import { pool } from "../../core/concurrency.js";
 import { selectRevisionPair, sourceObjectsOf, versionNumber } from "../../core/revisions.js";
 import { describeOrder, orderHeaders } from "../../core/transport.js";
 import { defineTool } from "../../core/tool.js";
 const resolveRef = (c, ref) => resolveByTypePrefix(c, ref.name, ref.types);
 const label = (r) => r ? `${r.version || "sin orden"} (v${versionNumber(r) || "?"}, ${r.date.slice(0, 10)}, ${r.author})` : "—";
-/** Limita cuántas promesas corren a la vez (no saturar SAP). */
-async function pool(items, n, fn) {
-    const out = new Array(items.length);
-    let next = 0;
-    await Promise.all(Array.from({ length: Math.min(n, items.length) }, async () => {
-        while (next < items.length) {
-            const i = next++;
-            out[i] = await fn(items[i]);
-        }
-    }));
-    return out;
-}
 export default defineTool({
     name: "transport_diff",
     timeoutMs: 180_000,

package/docs/TOOLS.md

@@ -1,13 +1,13 @@
 # Referencia de tools — abap-adt-doZimple
 
-Generado desde el código con `npm run docs`. 48 tools en 9 grupos y 3 flujos guiados.
+Generado desde el código con `npm run docs`. 51 tools en 9 grupos y 3 flujos guiados.
 Producto de [DoZimple](https://dozimple.cl).
 
 ## Índice
 
 - [Revisión de código y pases](#revision) — 5 tools: `transport_diff`, `transport_contents`, `co_change`, `inactive_objects`, `edit_preflight`
-- [Calidad, ATC y remediación](#calidad) — 5 tools: `run_atc`, `atc_quickfix`, `api_release_state`, `syntax_check`, `run_unit_tests`
-- [Exploración del repositorio](#exploracion) — 9 tools: `search_objects`, `get_source`, `where_used`, `object_versions`, `package_contents`, `ddic_type_info`, `transaction_info`, `function_modules`, `text_elements`
+- [Calidad, ATC y remediación](#calidad) — 6 tools: `run_atc`, `atc_quickfix`, `api_release_state`, `sap_notes`, `syntax_check`, `run_unit_tests`
+- [Exploración del repositorio](#exploracion) — 11 tools: `search_objects`, `get_source`, `where_used`, `source_search`, `object_versions`, `package_contents`, `ddic_type_info`, `transaction_info`, `function_modules`, `text_elements`, `enhancements`
 - [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`
@@ -185,6 +185,33 @@ Estado de liberación de un objeto SAP (clase, FM/BAPI, tabla, CDS…) por contr
 
 \* obligatorio
 
+### `sap_notes` — Notas SAP en el sistema (SNOTE)
+
+Estado de notas SAP en este sistema, como en SNOTE: si está descargada, estado de implementación (completa, incompleta, versión anterior, se puede implementar, obsoleta, no se puede implementar), estado de tratamiento, versión, componente y título. Con notes=[…] responde por notas concretas (p. ej. «¿está la 2198647 en PRD?»); sin notas, lista las del estado pedido. Solo conoce las notas descargadas en el sistema: no consulta el portal.
+
+| | |
+|---|---|
+| **Acceso** | Solo lectura |
+| **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. |
+| `notes` | lista de string |  |  |
+| `implementation` | lista de `E` \| `U` \| `V` \| `N` \| `O` \| `-` |  | Sin notes: filtrar por estado de implementación (E completa, U incompleta, V versión anterior, N se puede implementar, O obsoleta, - no se puede) |
+| `component` | string |  | Sin notes: prefijo de componente, p. ej. SD-BF o MM-PUR |
+| `max` | number | 100 |  |
+
+\* obligatorio
+
+Salida estructurada (`structuredContent`, además del texto):
+
+| Campo | Tipo | Descripción |
+|---|---|---|
+| `notes` | lista de { note, downloaded, implementation, implementation_code, processing, version, component, title, processor } |  |
+| `total` | number |  |
+| `truncated` | boolean |  |
+
 ### `syntax_check` — Chequeo de sintaxis SAP
 
 Chequeo de sintaxis real de SAP (no abaplint). Si pasas `source`, se comprueba ESE código sin guardarlo: sirve para validar un cambio antes de escribirlo. Sin `source`, comprueba lo último guardado.
@@ -298,6 +325,41 @@ Lista de uso (where-used) de un objeto: quién lo referencia, con paquete y resp
 
 \* obligatorio
 
+### `source_search` — Buscar texto en el código
+
+Busca un texto (o una expresión regular) en el código fuente de un paquete (con subpaquetes), de una orden de transporte o de una lista de objetos, y devuelve objeto, include, línea y la línea encontrada. Sirve donde where_used no llega: llamadas dinámicas, literales, código Z que el índice de referencias no cubre. Lee cada fuente, así que exige un alcance y tiene tope de objetos; los objetos que no se pudieron leer se listan aparte.
+
+| | |
+|---|---|
+| **Acceso** | Solo lectura |
+| **Créditos** | [abap-adt-api](https://github.com/marcellourbani/abap-adt-api) — Marcello Urbani (MIT, dependencia)<br>[vibing-steampunk](https://github.com/oisee/vibing-steampunk) — oisee y contribuidores (MIT, idea) |
+
+| Parámetro | Tipo | Por defecto | Descripción |
+|---|---|---|---|
+| `system` | string |  | Sistema SAP configurado. Obligatorio si hay varios y ninguno por defecto. |
+| `text` * | string |  | Texto a buscar (sin distinguir mayúsculas), p. ej. RV_FLOW o 'CALL FUNCTION' |
+| `regex` | boolean | false | Tratar text como expresión regular (máx. 200 caracteres) |
+| `package` | string |  | Alcance: paquete de desarrollo |
+| `include_subpackages` | boolean | true |  |
+| `transport` | string |  | Alcance: orden (o tarea) de transporte |
+| `objects` | lista de string |  | Alcance: lista de objetos por nombre |
+| `ignore_comments` | boolean | false | No contar líneas de comentario |
+| `max_objects` | number | 150 |  |
+| `max_hits` | number | 300 |  |
+
+\* obligatorio
+
+Salida estructurada (`structuredContent`, además del texto):
+
+| Campo | Tipo | Descripción |
+|---|---|---|
+| `scope` | string |  |
+| `objects_in_scope` | number |  |
+| `scanned` | number | Objetos leídos |
+| `truncated` | boolean | true si el alcance tenía más objetos que max_objects o más coincidencias que max_hits |
+| `hits` | lista de { object, type, include, line, text } |  |
+| `skipped` | lista de { object, reason } | Objetos que no se pudieron leer |
+
 ### `object_versions` — Versiones de un objeto
 
 Historial de versiones de un objeto (fecha, autor, orden). Con show=N devuelve la fuente de la versión N de la lista (1 = la más reciente), para comparar con la actual.
@@ -405,6 +467,37 @@ Lee los símbolos de texto (TEXT-001…), textos de selección o encabezados de
 
 \* obligatorio
 
+### `enhancements` — Ampliaciones y BAdI
+
+Qué ampliaciones hay y dónde. badi=NOMBRE: implementaciones de esa BAdI, nuevas y clásicas, activas o no. program + program_type (PROG, CLAS, FUGR): ampliaciones de código (puntos y secciones implícitos o explícitos) implementadas dentro de ese programa, clase o grupo — lo que cambia el comportamiento de un estándar sin tocar su código. prefix (p. ej. Z): implementaciones de ampliación de ese espacio de nombres, por tipo. Solo lectura.
+
+| | |
+|---|---|
+| **Acceso** | Solo lectura |
+| **Créditos** | [abap-adt-api](https://github.com/marcellourbani/abap-adt-api) — Marcello Urbani (MIT, dependencia)<br>[vibing-steampunk](https://github.com/oisee/vibing-steampunk) — oisee y contribuidores (MIT, idea) |
+
+| Parámetro | Tipo | Por defecto | Descripción |
+|---|---|---|---|
+| `system` | string |  | Sistema SAP configurado. Obligatorio si hay varios y ninguno por defecto. |
+| `badi` | string |  | Definición de BAdI, p. ej. MB_MIGO_BADI |
+| `program` | string |  | Programa, clase o grupo de funciones ampliado, p. ej. SAPMV45A |
+| `program_type` | `PROG` \| `CLAS` \| `FUGR` | "PROG" |  |
+| `prefix` | string |  | Implementaciones cuyo nombre empieza así, p. ej. Z o ZSD |
+| `tool_type` | string |  | Con prefix: filtrar por tipo, p. ej. BADI_IMPL o HOOK_IMPL |
+| `max` | number | 200 |  |
+
+\* obligatorio
+
+Salida estructurada (`structuredContent`, además del texto):
+
+| Campo | Tipo | Descripción |
+|---|---|---|
+| `mode` | `badi` \| `program` \| `prefix` |  |
+| `target` | string |  |
+| `rows` | lista de record |  |
+| `total` | number |  |
+| `truncated` | boolean |  |
+
 <a id="datos"></a>
 ## Consulta de datos
 
@@ -464,7 +557,7 @@ Filas de una tabla, vista o CDS, con columnas y filtro opcionales. Atajo de sql_
 
 ### `dumps` — Dumps (ST22)
 
-Lista los dumps de ejecución (ST22): fecha, error, programa, usuario y texto corto. Filtra por usuario y por texto (error o programa). Con detail=N devuelve el dump N completo (qué pasó, análisis, dónde terminó, fuente, pila).
+Lista los dumps de ejecución (ST22): fecha, error, programa, usuario y texto corto. Filtra por usuario y por texto (error o programa). Con detail=N devuelve el dump N completo (qué pasó, análisis, dónde terminó, fuente, pila). Con group_by (error, program, error_program, user, day) y days=N responde «los errores más frecuentes del periodo»: cuenta los dumps de los últimos N días agrupados, con primer y último caso, usuarios afectados y dónde terminó. La lista y el detalle salen del feed ADT (solo los más recientes); los grupos, de la cabecera de ST22 (SNAP_BEG).
 
 | | |
 |---|---|
@@ -479,9 +572,24 @@ Lista los dumps de ejecución (ST22): fecha, error, programa, usuario y texto co
 | `contains` | string |  | Filtra por error o programa, p. ej. CALL_FUNCTION_NOT_FOUND o ZFI_REPORTE |
 | `max` | number | 20 |  |
 | `detail` | number |  | Número de la lista para ver el dump completo |
+| `group_by` | `error` \| `program` \| `error_program` \| `user` \| `day` |  | Agrupar los dumps del periodo: por error, programa, error+programa, usuario o día |
+| `days` | number | 7 | Periodo hacia atrás para group_by (días) |
 
 \* obligatorio
 
+Salida estructurada (`structuredContent`, además del texto):
+
+| Campo | Tipo | Descripción |
+|---|---|---|
+| `mode` | `list` \| `detail` \| `groups` |  |
+| `total` | number | Dumps considerados (feed leído o filas del periodo) |
+| `period_days` | number |  |
+| `since` | string | AAAAMMDD desde el que se contó |
+| `truncated` | boolean | true si el periodo tiene más dumps de los que se pudieron leer |
+| `group_by` | `error` \| `program` \| `error_program` \| `user` \| `day` |  |
+| `groups` | lista de { key, count, first, last, users, where } |  |
+| `dumps` | lista de { n, error, program, user } |  |
+
 ### `jobs` — Jobs de fondo (SM37)
 
 Jobs de fondo por nombre (admite *), usuario, estado y fecha, con sus pasos (programa y variante). Responde «¿corrió anoche el job de X?, ¿por qué se canceló?». El log detallado del job sigue en SM37.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dozimple/abap-adt",
-  "version": "1.1.0",
+  "version": "1.2.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",