parche-cli 0.6.5 → 0.6.7

package/CHANGELOG.md

@@ -1,6 +1,56 @@
 # Cambios
 
-Todas las versiones de `parche-cli` (npm) y de la Action `Pepo08/parche@v0`.
+Los cambios de cada versión de `parche-cli` y de la Action `Pepo08/parche@v0`. En npm están la 0.1.1, la 0.5.1 y de la 0.6.0 en adelante. La 0.1.0 y de la 0.2.0 a la 0.5.0 no se publicaron en npm; lo que traían está incluido en la 0.5.1. La fecha de cada versión es la del cambio; la de publicación figura en npm y en los [Releases](https://github.com/Pepo08/parche/releases).
+
+## 0.6.7 — 2026-10-21
+
+Pack de IA con la API version `2026-10-21` de Anthropic, que salió el 21/10 junto con el SDK de TypeScript 1.0.0 y el de Python 2.0.0: elimina `temperature`, `top_p` y `top_k` para cualquier modelo, y un pedido que los manda devuelve un error 400 aunque tengan su valor por defecto (guía "Migrating to API version 2026-10-21" y página de deprecaciones, verificadas el 21/10). Los SDK anteriores siguen mandando `2023-06-01`, así que hoy casi nada se rompe: se rompe con la próxima suba del SDK. Como siempre, Parche avisa y no toca el código. Esta versión trae además las bases de confianza del repo (al final).
+
+### Nuevo
+- **Los tres parámetros con cualquier modelo,** también Claude Sonnet 4.6, Opus 4.6 y Haiku 4.5, que en `2023-06-01` los aceptan. El aviso dice en cuál de tres casos está el pedido:
+  - **ya falla:** el archivo manda `anthropic-version: 2026-10-21`, o el SDK instalado ya es el nuevo (`@anthropic-ai/sdk` 1.0.0 o posterior; `anthropic` 2.0.0 o posterior por `extra_body`). En Python, el parámetro directo ya tira `TypeError` desde la 1.0.0 (MIGRATION.md del SDK);
+  - **falla en una instalación nueva:** el rango declarado no tiene tope (`>=0.30.0`, `>=0.40`) y ya deja instalar la versión nueva;
+  - **va a fallar con la suba:** el SDK instalado es anterior; el aviso pide sacar el parámetro antes de aceptar esa suba.
+- **Sin repetir avisos:** lo que ya marca la regla de Claude 4.7 (un valor fuera de lo aceptado) sale una sola vez. En un modelo que todavía acepta otros valores, el aviso aclara que sacarlo cambia cómo responde y que la alternativa es dejar ese pedido en `2023-06-01`. Un archivo que fija `anthropic-version: 2023-06-01` no se avisa.
+- **Versión de Python desde `requirements.txt`:** el contexto del repo ahora también trae las versiones declaradas de Python y el rango tal como está escrito.
+- **PRs abiertos con el `GITHUB_TOKEN`:** GitHub deja sus workflows esperando aprobación. Cuando la Action corre con el token por defecto, el cuerpo del PR lo dice y explica cómo usar un token de GitHub App o uno personal para que la CI corra sola (README, "En GitHub Actions").
+- **La Action se llama "Parche API Changes"** (antes, "Parche — Dependabot para APIs"), para publicarla en el GitHub Marketplace. Sus reglas no aceptan un nombre igual a una función de GitHub (Dependabot, que queda solo en la descripción) ni a un usuario de GitHub (existe la cuenta `parche`).
+
+### Cambios
+- La fuente del `TypeError` del SDK de Python pasa a ser su MIGRATION.md de la 1.0.0: la guía de migración a Opus 5.5 ya no lo menciona.
+
+### Todavía no cubre
+- La versión del SDK de Python desde `pyproject.toml`, `poetry.lock` o `uv.lock`, y los rangos sin número (`latest`, `*`), que cuentan como versión desconocida.
+- Los SDKs de Go (v2), Java (3.0.0), .NET (13.0.0), Ruby (2.0.0) y PHP (1.0.0), que también pasan a `2026-10-21`.
+- Los otros cambios de esa API version: bloques `document` en mensajes de `assistant`, `citations` en mensajes de `user` y los campos renombrados de la Admin API.
+
+### Bases de confianza del repo
+
+Qué hace Parche con tu código, cómo reportar una vulnerabilidad y cómo contribuir.
+
+- **`SECURITY.md`:** cómo reportar una vulnerabilidad (en privado, primera respuesta en 14 días como máximo) y qué hace Parche en tu máquina o en tu runner: a qué hosts se conecta y con qué comando, que no tiene telemetría, qué ejecuta (tus tests, solo con `--verify`) y qué archivos escribe.
+- **README:** un bloque en inglés al principio, la sección "Seguridad y datos" y qué puede cambiar dentro de `v0`.
+- **`CONTRIBUTING.md`** (con el proceso para sacar una versión, que sale del README), **código de conducta**, plantillas de issue (falso positivo o aviso que falta, pedido de pack, error) y de PR.
+- **`parche --version`.**
+- **"¿Por qué recibí un PR de Parche?"** ([`docs/por-que-recibi-este-pr.md`](docs/por-que-recibi-este-pr.md)): para quien recibe un PR o un issue de Parche. Explica por qué su repo, cómo se revisó el PR, qué se verificó y qué no, y cómo pedir que no le manden más. El pie de cada PR y de cada issue la enlaza.
+- **La plantilla del workflow pide solo lectura por defecto** y da `contents: write` y `pull-requests: write` solo al job de Parche. Explica cómo fijar la Action a un commit en vez de `v0`.
+- **Las Actions de la CI, del release y de la plantilla quedan fijadas por SHA** (`actions/checkout` v7.0.1, `actions/setup-node` v7.1.0), con `dependabot.yml` para mantenerlas al día.
+- `package.json`: la descripción dice "cualquier API", la página es getparche.com y suma keywords de IA.
+
+## 0.6.6 — 2026-10-20
+
+Pack de IA con el primer cambio de Anthropic que no es un retiro de modelo: desde Claude 4.7, `temperature`, `top_p` y `top_k` con un valor que no es el de por defecto dan error 400 (página de deprecaciones de Anthropic, sección "API parameter deprecations", verificada el 20/10; los valores aceptados, de la referencia de la API y de las guías de migración). Como siempre, Parche avisa y no toca el código.
+
+### Nuevo
+- **Parámetros de muestreo en Claude 4.7 y posteriores:** en `claude-opus-4-7`, `claude-opus-4-8`, `claude-opus-5`, `claude-opus-5-5`, `claude-sonnet-5`, `claude-sonnet-5-5`, `claude-haiku-5-5`, `claude-fable-5`, `claude-fable-5-1`, `claude-mythos-5`, `claude-mythos-5-1` y `claude-mythos-preview`, avisa `temperature` distinto de 1, `top_p` por debajo de 0.99 y `top_k` con cualquier valor. En Claude Haiku 5.5, que es más estricto, también `top_p` distinto de 0.99 (incluso 1) y `temperature` y `top_p` juntos. El aviso dice el parámetro, el modelo, qué acepta y la recomendación oficial: sacar el parámetro y guiar el comportamiento del modelo con el prompt. Con `temperature` en 0 aclara que, según Anthropic, eso nunca garantizó respuestas idénticas; en Python, que el SDK 1.0 o posterior ya no tiene esos parámetros (pasarlos tira `TypeError`).
+- **Dónde lo busca:** en lo que recibe `messages.create` y `messages.stream` del SDK de JS/TS y del de Python (también `beta.`, `with_raw_response.` y `create(params)` / `create(**params)` con el objeto en el mismo archivo), en objetos tipados como `MessageCreateParams` y en el cuerpo de las llamadas HTTP directas a `api.anthropic.com/v1/messages` (fetch, axios, requests). El modelo y el parámetro pueden estar en líneas distintas del pedido.
+- **El modelo, sin inventar:** se lee si es un literal, una constante asignada una sola vez en el archivo o el valor por defecto de una variable (`process.env.CLAUDE_MODEL || '…'`, `os.getenv("CLAUDE_MODEL", "…")`), y el aviso dice cuál de los dos es. Si el modelo no se puede saber (llega de otro archivo, de la configuración o se asigna más de una vez), no avisa.
+- **Sin falsos positivos con otros modelos y proveedores:** Claude Sonnet 4.6, Opus 4.6, Haiku 4.5 y anteriores aceptan los tres parámetros; OpenAI, Gemini y la capa de Anthropic compatible con el SDK de OpenAI no se avisan.
+
+### Todavía no cubre
+- La versión instalada del SDK de Python: con la 1.0 o posterior, pasar `temperature`, `top_p` o `top_k` tira `TypeError` con cualquier valor y cualquier modelo, pero hoy solo se dice en los avisos de Claude 4.7 y posteriores.
+- Frameworks que arman el pedido por su cuenta (LangChain, Vercel AI SDK, LiteLLM), la Message Batches API y los IDs de modelo de Amazon Bedrock (`anthropic.claude-…`).
+- Los SDKs de Go, Java, .NET, Ruby y PHP, y los cuerpos de pedido escritos como texto JSON dentro de un string.
 
 ## 0.6.5 — 2026-10-19
 

package/README.md

@@ -1,6 +1,12 @@
 # Parche — Dependabot para APIs
 
 [![CI](https://github.com/Pepo08/parche/actions/workflows/ci.yml/badge.svg)](https://github.com/Pepo08/parche/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/parche-cli)](https://www.npmjs.com/package/parche-cli)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
+
+> **In English.** Parche reads your code and inventories every third-party API it uses: SDKs, direct HTTP calls and AI model IDs. When a provider ships a dated change that affects you, it tells you the file and the line, or opens a small PR with a deterministic fix. Every changed file is parsed before the PR, and with `--verify` your own tests run too. What can't be inferred is never made up: the PR asks for it. Today's packs cover Argentina's ARCA e-invoicing change (due December 1, 2026), Mercado Pago Payments → Orders, and OpenAI and Anthropic model and parameter deprecations.
+>
+> Try it with `npx parche-cli scan .` (Node 22+): it runs locally, with no account and no telemetry ([security and data](SECURITY.md)). GitHub Action: `uses: Pepo08/parche@v0`. The rest of this README is in Spanish for now · [getparche.com](https://getparche.com) · hola@getparche.com
 
 Parche lee tu código y arma el inventario de **todas** las APIs de terceros que usás: SDKs (Stripe, Twilio, OpenAI, AWS, Mercado Pago, ARCA…), llamadas HTTP directas y modelos de IA. Lo cruza contra una base de **cambios de API verificados** y, cuando un proveedor cambia algo que te afecta, te avisa o abre un PR con el arreglo, explica qué cambió y por qué, y marca lo que necesita una persona. Ningún PR sale sin pasar la verificación. Las APIs de pagos y facturación de Latinoamérica son el fuerte, pero el inventario cubre cualquier API.
 
@@ -20,7 +26,7 @@ APIs del repo (6):
   👀 revisar       src/facturacion.js:56  Agregado CondicionIVAReceptorId: 5 por inferencia (DNI + comprobante B/C)…
   ✋ falta un dato  src/facturacion.js:62  Falta CondicionIVAReceptorId y no se puede inferir… (comprobante clase A).
 
-■ Modelos y endpoints de IA retirados o por retirarse
+■ Modelos, endpoints y parámetros de IA retirados o por retirarse
   🔎 detectado     src/ia.js:9  El modelo `claude-3-5-haiku-20241022` fue retirado el 2026-02-19: las llamadas ya fallan…
 …
 ```
@@ -87,6 +93,14 @@ Para que corra todas las semanas, copiá [`templates/github-workflow.yml`](templ
 
 El workflow necesita `permissions: contents: write` y `pull-requests: write`.
 
+Con el `GITHUB_TOKEN` por defecto, GitHub deja los workflows del PR que abre Parche esperando aprobación: alguien con permiso de escritura tiene que tocar **Approve workflows to run** (el cuerpo del PR lo avisa). Para que tu CI corra sola sobre esos PRs, pasale a la Action un token de una GitHub App o un token personal con permiso de escritura en `contents` y `pull-requests`:
+
+```yaml
+- uses: Pepo08/parche@v0
+  with:
+    token: ${{ secrets.PARCHE_TOKEN }}
+```
+
 ### Desarrollo
 
 ```bash
@@ -98,22 +112,7 @@ node bin/parche.js scan examples/saas-demo    # SaaS con Stripe, Twilio, OpenAI
 node bin/parche.js scan examples/legacy-ia --upgrades   # OpenAI v3: qué se rompe al actualizar (usa la red)
 ```
 
-#### Sacar una versión
-
-Las versiones se publican solas desde GitHub Actions ([`release.yml`](.github/workflows/release.yml)) con [trusted publishing](https://docs.npmjs.com/trusted-publishers): npm confía en este repo y en ese workflow, sin tokens ni 2FA a mano. Desde `main` actualizado:
-
-```bash
-npm version 0.1.2 --no-git-tag-version            # cambia package.json y package-lock.json
-git commit -am "Parche 0.1.2"
-git tag -a v0.1.2 -m "Parche 0.1.2: qué cambió"   # el mensaje del tag es el texto del GitHub Release
-git push origin main v0.1.2
-```
-
-Con el tag, el workflow corre los tests, controla que la versión de `package.json` coincida con el tag y que el commit esté en `main`, publica `parche-cli` en npm (con provenance), mueve `v0` a esta versión (es la que usan los workflows con `Pepo08/parche@v0`) y crea el GitHub Release. Para notas largas, `git tag -a v0.1.2 -F notas.md`.
-
-- Solo dispara con versiones estables (`vX.Y.Z`); un tag como `v0.2.0-beta.1` no hace nada.
-- Si falla un paso después de publicar, "Re-run failed jobs" retoma: lo que ya está hecho se saltea.
-- Requiere, una sola vez, el Trusted Publisher en npmjs.com: `parche-cli` → Settings → Trusted publishing → GitHub Actions, con `Pepo08` / `parche` / `release.yml` y permiso para `npm publish`.
+Cómo contribuir, las reglas para el código y cómo se saca una versión: [`CONTRIBUTING.md`](CONTRIBUTING.md).
 
 ## Estados de cada hallazgo
 
@@ -131,7 +130,7 @@ Con el tag, el workflow corre los tests, controla que la versión de `package.js
 |---|---|---|---|---|
 | `arca.wsfe.condicion-iva-receptor` | ARCA | rompe | 2026-12-01 | sí, en JS (`afip.js`) y PHP (`afipsdk/afip.php` y forks): consumidor final y DNI B/C; con `DocTipo` en una variable, consumidor final al ejecutarse (PR parcial) |
 | `mercadopago.payments-to-orders` | Mercado Pago | migración | — | sí (creación de pagos en SDK Node v2) |
-| `ai.model-retirements` | Anthropic, OpenAI | retiro | varias | solo detección (también modelos fine-tuned de OpenAI, `ft:…`). De OpenAI, los modelos que su página de deprecaciones apaga desde 2026: texto, código, imagen, video, voz, transcripción y realtime; y los productos que cierran: Assistants API, prompts reutilizables (`pmpt_…`, `v1/prompts`), la plataforma de Evals, ChatKit con un workflow de Agent Builder y la Videos API (cerrada el 24/9/2026) |
+| `ai.model-retirements` | Anthropic, OpenAI | retiro | varias | solo detección (también modelos fine-tuned de OpenAI, `ft:…`). De OpenAI, los modelos que su página de deprecaciones apaga desde 2026: texto, código, imagen, video, voz, transcripción y realtime; y los productos que cierran: Assistants API, prompts reutilizables (`pmpt_…`, `v1/prompts`), la plataforma de Evals, ChatKit con un workflow de Agent Builder y la Videos API (cerrada el 24/9/2026). De Anthropic, los modelos retirados, `temperature`, `top_p` y `top_k` con un valor que no es el de por defecto en Claude 4.7 y posteriores, que dan error 400 (SDK de JS/TS y de Python, y HTTP directo), y los mismos tres parámetros con cualquier modelo en la API version `2026-10-21`, que usan el SDK de TypeScript 1.0.0 y el de Python 2.0.0 (del 21/10/2026): dice si el pedido ya falla, si falla en una instalación nueva o si va a fallar cuando suban el SDK |
 
 ## Verificación
 
@@ -141,6 +140,21 @@ Antes de commitear, Parche parsea **siempre** cada archivo modificado (JS/TS o P
 
 **Copias de respaldo:** Parche no lee ni edita carpetas `BAK/`, `backup/`, `old/`, `_old/` y `deprecated/`, ni archivos como `factura copy.php`, `factura - Copy.js`, `factura.bak.php` o `factura-old.php`. El scan dice cuáles saltó, por si alguno es código que corre.
 
+## Seguridad y datos
+
+Parche corre en tu máquina o en tu runner. Tu código no sale de ahí, salvo el PR que abre en tu propio repo.
+
+| | |
+|---|---|
+| **Red** | `scan`, `fix` y `packs` no usan la red. `pr` llama a `api.github.com` para abrir el PR en tu repo y pushea su rama `parche/<pack>` (con `--force`, así solo reemplaza su propio PR anterior). `diff` y `scan --upgrades` bajan metadatos y paquetes de `registry.npmjs.org`, que ve qué paquetes y versiones consultás. Nada más. |
+| **Telemetría** | Ninguna. `parche feedback` escribe en `.parche/ledger.jsonl` de tu repo y queda ahí. |
+| **Qué ejecuta** | `git` y, solo con `--verify`, los tests de tu repo (`npm test`, `composer test` o `vendor/bin/phpunit`). |
+| **Qué escribe** | Tu working copy (solo `fix` y `pr`), `.parche/` (se agrega a `.git/info/exclude`) y, para `diff` y `--upgrades`, un caché en `~/.parche/cache`. |
+
+Para reportar una vulnerabilidad, y el detalle de todo esto: [`SECURITY.md`](SECURITY.md). Si te llegó un PR de Parche: [por qué lo recibiste](docs/por-que-recibi-este-pr.md).
+
+**Qué puede cambiar dentro de `v0`:** mientras Parche esté en 0.x, `Pepo08/parche@v0` y `npx parche-cli` reciben cada versión nueva. Una versión 0.x puede sumar packs, avisos y opciones. No cambia sin aviso en el CHANGELOG el formato de `.parche/inventory.json` (tiene `schemaVersion`), los nombres de los comandos ni el de los inputs de la Action. Si tu organización exige fijar las Actions, usá el commit de un release: `Pepo08/parche@<sha> # v0.6.7`.
+
 ## ARCA en PHP
 
 Para `afipsdk/afip.php` y sus forks (`fertandil87/afip.php`, `ivanalemunioz/afip.php`, `eesnaola/afip.php`), Parche busca `$afip->ElectronicBilling->CreateVoucher($data)` y `CreateNextVoucher($data)` (también en minúsculas: PHP no distingue) y agrega una línea por factura:
@@ -188,6 +202,8 @@ Cuando `DocTipo` no es un número fijo (`DocTipo: docTipo`), Parche no puede sab
 
 - JS/TS (ESM y CommonJS) y, para ARCA, PHP. Siguen Python y Java.
 - ARCA: cubre `@afipsdk/afip.js` y `afipsdk/afip.php` (con sus forks). Las integraciones SOAP propias (en cualquier lenguaje) se detectan pero no se reescriben.
+- IA, parámetros de Claude 4.7 y posteriores: avisa solo si el modelo del pedido se lee en el mismo archivo (un literal, una constante asignada una vez o el valor por defecto de una variable de entorno) y el parámetro es un número escrito en el código. Si el modelo llega de otro archivo o de la configuración, no avisa: no se puede saber si el pedido va a fallar.
+- IA, API version `2026-10-21` de Anthropic: la versión del SDK sale de `package-lock.json`, `node_modules` o el rango de `package.json`, y en Python solo de `requirements.txt` (todavía no de `pyproject.toml`, `poetry.lock` ni `uv.lock`). Un rango sin número (`latest`, `*`) cuenta como versión desconocida. Por HTTP directo avisa solo si el archivo manda `anthropic-version: 2026-10-21`. Los SDKs de Go, Java, .NET, Ruby y PHP no se leen.
 - Mercado Pago: migra la creación de pagos con el SDK v2. Las consultas, capturas y reembolsos de pagos existentes se dejan a propósito en Payments API, como indica la guía oficial.
 - Se distribuye como CLI (`npx parche-cli`) + GitHub Action (`Pepo08/parche@v0`). La GitHub App (instalación en un click, PRs automáticos al publicarse un pack nuevo) es el próximo paso.
 - La capa de LLM (redactar packs desde changelogs y resolver casos "falta un dato" leyendo el modelo de datos del cliente) todavía no está incluida; cuando entre, va a pasar por la misma verificación.

package/bin/parche.js

@@ -27,6 +27,7 @@ Uso:
                                        pushea a ese remote (tu fork) y abre el PR contra origin.
                                        Con --author, firma con esa identidad y no con la de git
   parche feedback <dir> --pack <id> --outcome merged|edited|rejected [--note "..."]
+  parche --version                     La versión instalada (para reportar un error)
 `;
 
 function parseArgs(argv) {
@@ -140,6 +141,11 @@ function printFindings(result) {
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   const [cmd, dirArg] = args._;
+  if (args.version || cmd === '-v') {
+    const pkg = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+    console.log(pkg.version);
+    return 0;
+  }
   if (!cmd || args.help) { console.log(HELP); return 0; }
 
   if (cmd === 'packs') {
@@ -243,7 +249,9 @@ async function main() {
         }
         // Si solo cambiarían tests o mocks no hay PR: el texto queda como issue, sin "Modifica 1 archivo" (frente B, punto 20).
         const reportOnly = !changedFiles.length || changedFiles.every(isTestFile);
-        fs.writeFileSync(bodyPath, prBody({ pack, findings: result.findings, changed: reportOnly ? [] : result.changed, verification: reportOnly ? null : verification }));
+        // La Action avisa si usa el GITHUB_TOKEN por defecto (PARCHE_DEFAULT_TOKEN): los workflows del PR esperan aprobación.
+        const ciApproval = process.env.GITHUB_ACTIONS === 'true' && process.env.PARCHE_DEFAULT_TOKEN === 'true';
+        fs.writeFileSync(bodyPath, prBody({ pack, findings: result.findings, changed: reportOnly ? [] : result.changed, verification: reportOnly ? null : verification, ciApproval }));
         if (reportOnly) {
           const why = changedFiles.length ? 'solo cambiaría tests o mocks: no se abre un PR' : 'sin cambios de código';
           git.discardChanges(root);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "parche-cli",
-  "version": "0.6.5",
-  "description": "Dependabot para APIs: detecta cambios de APIs de terceros en tu código y abre el PR con el arreglo.",
+  "version": "0.6.7",
+  "description": "Dependabot para APIs: detecta cambios de cualquier API de terceros en tu código (ARCA, Mercado Pago, OpenAI, Anthropic) y abre el PR con el arreglo.",
   "keywords": [
     "api",
     "migration",
@@ -11,9 +11,15 @@
     "afip",
     "wsfe",
     "mercadopago",
-    "github-action"
+    "github-action",
+    "openai",
+    "anthropic",
+    "claude",
+    "api-migration",
+    "deprecation",
+    "breaking-changes"
   ],
-  "homepage": "https://github.com/Pepo08/parche#readme",
+  "homepage": "https://getparche.com",
   "bugs": "https://github.com/Pepo08/parche/issues",
   "repository": {
     "type": "git",

package/packs/ai.model-retirements.json

@@ -1,16 +1,27 @@
 {
   "id": "ai.model-retirements",
-  "version": "2026.10.19",
+  "version": "2026.10.21",
   "provider": "Modelos de IA",
-  "title": "Modelos y endpoints de IA retirados o por retirarse",
+  "title": "Modelos, endpoints y parámetros de IA retirados o por retirarse",
   "kind": "retirement",
   "severity": "high",
   "deadline": null,
   "last_verified": "2026-10-19",
-  "summary_es": "Tu código usa modelos o APIs de IA que ya no responden o tienen fecha de retiro.",
-  "why_es": "Los proveedores de modelos retiran IDs de modelo y endpoints con algunas semanas o meses de aviso. Después de la fecha, las llamadas fallan. Parche no reemplaza el modelo automáticamente porque cambiar de modelo cambia el comportamiento: te avisa, te dice la fecha y el reemplazo que recomienda el proveedor.",
+  "summary_es": "Tu código usa modelos, APIs o parámetros de IA que ya no responden, tienen fecha de retiro o el modelo nuevo rechaza.",
+  "why_es": "Los proveedores de modelos retiran IDs de modelo y endpoints con algunas semanas o meses de aviso. Después de la fecha, las llamadas fallan. Parche no reemplaza el modelo automáticamente porque cambiar de modelo cambia el comportamiento: te avisa, te dice la fecha y el reemplazo que recomienda el proveedor. También avisa los parámetros que los modelos nuevos rechazan, como `temperature`, `top_p` y `top_k` en Claude 4.7 y posteriores.",
   "sources": [
     { "title": "Anthropic: Model deprecations", "url": "https://platform.claude.com/docs/en/about-claude/model-deprecations" },
+    { "title": "Anthropic: Model deprecations, API parameter deprecations (temperature, top_p y top_k en Claude 4.7 y posteriores)", "url": "https://platform.claude.com/docs/en/about-claude/model-deprecations#api-parameter-deprecations" },
+    { "title": "Anthropic: API reference, Messages (valores que se aceptan: temperature 1, top_p desde 0.99, top_k ninguno)", "url": "https://platform.claude.com/docs/en/api/messages/create" },
+    { "title": "Anthropic: Claude Haiku 5.5 migration guide (top_p solo 0.99; temperature y top_p juntos dan 400)", "url": "https://platform.claude.com/docs/en/models/haiku-5-5/migration-guide#remove-sampling-parameters" },
+    { "title": "Anthropic: Claude Opus 5.5 migration guide (Opus 4.7 y posteriores, Sonnet 5)", "url": "https://platform.claude.com/docs/en/models/opus-5-5/migration-guide" },
+    { "title": "Anthropic: Migrating to API version 2026-10-21 (temperature, top_p y top_k dan 400 con cualquier modelo; primera versión de cada SDK que la usa)", "url": "https://platform.claude.com/docs/en/api/migration-2026-10-21" },
+    { "title": "Anthropic: Versions (anthropic-version; historial de la API version 2026-10-21)", "url": "https://platform.claude.com/docs/en/api/versioning" },
+    { "title": "anthropic-sdk-python: MIGRATION.md de la 1.0.0 (temperature, top_p y top_k salen de los métodos: TypeError)", "url": "https://github.com/anthropics/anthropic-sdk-python/blob/v1.0.0/MIGRATION.md" },
+    { "title": "anthropic-sdk-python: release v2.0.0 del 21/10/2026 (API version 2026-10-21)", "url": "https://github.com/anthropics/anthropic-sdk-python/releases/tag/v2.0.0" },
+    { "title": "anthropic-sdk-typescript: release sdk-v1.0.0 del 21/10/2026 (API version 2026-10-21)", "url": "https://github.com/anthropics/anthropic-sdk-typescript/releases/tag/sdk-v1.0.0" },
+    { "title": "Anthropic: Claude Sonnet 5.5 migration guide (Sonnet 4.6 y anteriores y Haiku 4.5 aceptan los tres)", "url": "https://platform.claude.com/docs/en/models/sonnet-5-5/migration-guide" },
+    { "title": "Anthropic: Claude Fable 5.1 and Claude Mythos 5.1 migration guide (la restricción de muestreo se mantiene)", "url": "https://platform.claude.com/docs/en/models/fable-5-1/migration-guide" },
     { "title": "OpenAI: Deprecations", "url": "https://developers.openai.com/api/docs/deprecations" },
     { "title": "OpenAI: Supervised fine-tuning (formato de los IDs ft:)", "url": "https://developers.openai.com/api/docs/guides/supervised-fine-tuning" },
     { "title": "OpenAI: Models (snapshots de cada familia y de cada modelo base)", "url": "https://developers.openai.com/api/docs/models" },
@@ -163,6 +174,42 @@
       "claude-haiku-4-5-20251001": "2026-10-15",
       "claude-opus-4-5-20251101": "2026-11-24"
     },
+    "sampling_params": {
+      "last_verified": "2026-10-20",
+      "models": ["claude-opus-4-7", "claude-opus-4-8", "claude-opus-5", "claude-opus-5-5", "claude-sonnet-5", "claude-sonnet-5-5", "claude-haiku-5-5",
+        "claude-fable-5", "claude-fable-5-1", "claude-mythos-5", "claude-mythos-5-1", "claude-mythos-preview"],
+      "scope_es": "en Claude 4.7 y posteriores (y en Claude Mythos Preview)",
+      "accepted": {
+        "temperature": { "min": 1, "max": 1, "es": "solo acepta 1, su valor por defecto" },
+        "top_p": { "min": 0.99, "max": 1, "es": "solo acepta valores desde 0.99" },
+        "top_k": { "es": "no acepta ningún valor" }
+      },
+      "overrides": {
+        "claude-haiku-5-5": {
+          "scope_es": "en Claude Haiku 5.5",
+          "accepted": { "top_p": { "min": 0.99, "max": 0.99, "es": "solo acepta 0.99, su valor por defecto (ni siquiera 1)" } },
+          "exclusive": ["temperature", "top_p"],
+          "exclusive_es": "Claude Haiku 5.5 rechaza los pedidos que mandan los dos, aunque tengan sus valores por defecto"
+        }
+      },
+      "recommendation_es": "sacar {params} del pedido y guiar el comportamiento del modelo con el prompt",
+      "temperature_zero_es": "Si estaba en 0 para tener respuestas determinísticas: según Anthropic, eso nunca garantizó respuestas idénticas.",
+      "python_sdk_es": "Además, el SDK de Python 1.0 o posterior ya no tiene `temperature`, `top_p` ni `top_k`: pasarlos tira `TypeError`.",
+      "api_version": {
+        "version": "2026-10-21",
+        "last_verified": "2026-10-21",
+        "released_es": "21/10/2026",
+        "sdks": {
+          "npm": { "package": "@anthropic-ai/sdk", "first": "1.0.0" },
+          "pypi": { "package": "anthropic", "first": "2.0.0", "typeerror_from": "1.0.0" }
+        },
+        "removed_es": "esa versión de la API eliminó `temperature`, `top_p` y `top_k`: con cualquier modelo devuelven un error 400, aunque tengan su valor por defecto",
+        "recommendation_es": "sacá {param} del pedido y guiá el comportamiento del modelo con el prompt",
+        "typescript_es": "En TypeScript, además, el SDK 1.0 ya no tiene el parámetro en sus tipos.",
+        "older_models": ["claude-sonnet-4-6", "claude-sonnet-4-5", "claude-sonnet-4-2", "claude-opus-4-6", "claude-opus-4-5", "claude-opus-4-1", "claude-opus-4-2", "claude-haiku-4-5", "claude-3"],
+        "older_model_es": "Con {model}, que todavía acepta otros valores, sacarlo cambia cómo responde y ningún otro ajuste lo reemplaza: si dependés de ese valor, ese pedido tiene que quedarse en la API version `2023-06-01`."
+      }
+    },
     "retired_endpoints": [
       { "pattern": ".beta.assistants", "retired": "2026-08-26", "api_es": "Assistants API", "replacement_es": "Responses API + Conversations API", "provider": "openai" },
       { "pattern": ".beta.threads", "retired": "2026-08-26", "api_es": "Assistants API", "replacement_es": "Responses API + Conversations API", "provider": "openai" },
@@ -182,6 +229,6 @@
   "review_checklist_es": [
     "Elegir el modelo de reemplazo según la página de deprecaciones del proveedor.",
     "Correr tus evals o pruebas de regresión de prompts antes de cambiar de modelo.",
-    "Revisar parámetros que cambian entre generaciones de modelos."
+    "Revisar parámetros que cambian entre generaciones de modelos (desde Claude 4.7, `temperature`, `top_p` y `top_k`)."
   ]
 }

package/src/context.js

@@ -1,7 +1,8 @@
 // Contexto del repo para los packs: lo que un archivo solo no puede saber.
 // Lo arma el motor una vez, antes de correr los packs, y cada transform lo recibe como `context`.
 //
-//   versions:   versión instalada de cada dependencia (de los lockfiles, de node_modules o del rango declarado)
+//   versions:   versión instalada de cada dependencia (de los lockfiles, de node_modules o del rango declarado;
+//               en Python, solo el rango de requirements.txt). Si sale del rango, `range` trae el texto declarado.
 //   fieldFiles: archivos que ya usan CondicionIVAReceptorId (el repo ya empezó a migrar)
 //   staleWsdl:  WSDL de WSFEv1 del repo que no tienen CondicionIVAReceptorId
 //   arcaLibs:   librerías de ARCA del repo con lo que se sabe de si el campo llega a viajar
@@ -20,8 +21,10 @@ const clean = (v) => String(v || '').replace(/^v/, '');
 
 // Versiones instaladas por ecosistema: lockfiles (en cualquier carpeta) → node_modules de la raíz → rango declarado.
 export function readVersions(root, manifests) {
-  const out = { npm: {}, composer: {} };
-  const set = (eco, name, version, source) => { if (name && version && !out[eco][name]) out[eco][name] = { version: clean(version), source }; };
+  const out = { npm: {}, composer: {}, pypi: {} };
+  const set = (eco, name, version, source, range) => {
+    if (name && version && !out[eco][name]) out[eco][name] = { version: clean(version), source, ...(range ? { range } : {}) };
+  };
   for (const rel of findFiles(root, (n) => n === 'package-lock.json' || n === 'composer.lock')) {
     const lock = readJson(path.join(root, rel));
     if (!lock) continue;
@@ -39,15 +42,19 @@ export function readVersions(root, manifests) {
     const pkg = readJson(path.join(root, 'node_modules', name, 'package.json'));
     if (pkg?.version) set('npm', name, pkg.version, 'node_modules');
   }
-  for (const eco of ['npm', 'composer']) {
+  for (const eco of ['npm', 'composer', 'pypi']) {
     for (const [name, range] of Object.entries(manifests?.[eco] || {})) {
       const m = String(range).match(/(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
-      if (m) set(eco, name, `${m[1]}.${m[2] || 0}.${m[3] || 0}`, 'declarada');
+      if (m) set(eco, name, `${m[1]}.${m[2] || 0}.${m[3] || 0}`, 'declarada', String(range));
     }
   }
   return out;
 }
 
+// ¿Un rango declarado deja instalar versiones mayores nuevas? `>=0.40`, `>0.3`, `*`, `x` o `latest` sin tope (`<`):
+// una instalación nueva trae la última versión. `^0.137.0`, `~1.2`, `==1.4.0` o `~=1.2` no.
+export const openRange = (range) => /^\s*(?:>=?|\*|x|latest)/i.test(range || '') && !/</.test(range || '');
+
 // Qué se sabe, por librería, de si CondicionIVAReceptorId llega a ARCA (verificado en su código el 16/10/2026):
 //   afip.js / afip.php ≥ 1.0: mandan JSON a la API de Afip SDK → sí.
 //   0.x: arman el SOAP con un WSDL de 2021 incluido en la librería, sin el campo → no (PHP) o sin confirmar (JS).
@@ -90,4 +97,4 @@ export function buildContext(root, files, manifests) {
   return { versions, fieldFiles, staleWsdl, arcaLibs: arcaLibraries(versions) };
 }
 
-export const emptyContext = () => ({ versions: { npm: {}, composer: {} }, fieldFiles: [], staleWsdl: [], arcaLibs: [] });
+export const emptyContext = () => ({ versions: { npm: {}, composer: {}, pypi: {} }, fieldFiles: [], staleWsdl: [], arcaLibs: [] });

package/src/detectors/ai-model-retirements.js

@@ -4,6 +4,8 @@
 // Menos ruido (frente B, 16/10): un ID que aparece en el contexto de una llamada (model: '...', DEFAULT_MODEL)
 // es un uso; si aparece en una lista o un catálogo, se avisa como mención. Y en código de Azure OpenAI no se
 // da por cerrada la Assistants API: la fecha oficial es la de la API de OpenAI.
+import samplingParams from './anthropic-sampling-params.js';
+
 const PACK = 'ai.model-retirements';
 
 const MODEL_CONTEXT = /\bmodel(?:Id|Name)?\b\s*[:=(]|["']model["']\s*[:=]|\b(?:DEFAULT|default)_?(?:MODEL|Model)\b|\bmodel\s*\(/i;
@@ -36,7 +38,7 @@ const endpointHit = (ep, l) => {
 const milestonesText = (ep, today) => (ep.milestones || [])
   .map((m) => (m.date <= today ? ` Desde el ${m.date} ${m.past_es}.` : ` El ${m.date} ${m.future_es}.`)).join('');
 
-export default function detect({ source, file, pack, today = new Date().toISOString().slice(0, 10) }) {
+export default function detect({ source, file, pack, today = new Date().toISOString().slice(0, 10), context }) {
   const findings = [];
   const usages = [];
   const { retired_models: retired, retirement_floors: floors, retired_endpoints: endpoints } = pack.detect;
@@ -92,5 +94,10 @@ export default function detect({ source, file, pack, today = new Date().toISOStr
       usages.push({ provider: 'ia', op: `OpenAI ${ep.api_es}`, line });
     }
   });
+  // `temperature`, `top_p` y `top_k` (Claude 4.7 y posteriores, API version 2026-10-21): el modelo y el parámetro pueden estar en líneas
+  // distintas del pedido, así que va aparte (anthropic-sampling-params.js).
+  const sampling = samplingParams({ source, file, pack, context });
+  findings.push(...sampling.findings);
+  usages.push(...sampling.usages);
   return { output: null, findings, usages };
 }

package/src/detectors/anthropic-sampling-params.js

@@ -0,0 +1,408 @@
+// Pack ai.model-retirements — `temperature`, `top_p` y `top_k` en Claude 4.7 y posteriores. Solo detección.
+// Desde Claude 4.7 (y en Claude Mythos Preview), la API de Anthropic devuelve 400 si alguno de los tres llega con un
+// valor distinto del de por defecto (página de deprecaciones, "API parameter deprecations"). Los valores aceptados
+// salen de la referencia de la API (`temperature` 1, `top_p` desde 0.99, `top_k` ninguno) y de la guía de Claude
+// Haiku 5.5, que es más estricta (`top_p` solo 0.99, y nunca `temperature` y `top_p` juntos).
+//
+// El modelo y el parámetro suelen estar en líneas distintas del mismo pedido, así que no alcanza con mirar una línea
+// como en los modelos retirados: se tokeniza el archivo (strings y comentarios de JS/TS o de Python), se arma el árbol
+// de paréntesis y llaves, y se mira cada objeto que es un pedido a la API de Messages:
+//   1. lo que recibe `.messages.create(` o `.messages.stream(` (también `beta.` y `with_raw_response.`): el objeto en
+//      JS, los argumentos con nombre en Python;
+//   2. el objeto asignado a la variable que recibe esa llamada (`create(params)`, `create(**params)`);
+//   3. un objeto tipado como `MessageCreateParams…`;
+//   4. si el archivo nombra `api.anthropic.com` y `v1/messages` (HTTP directo): cualquier objeto con `messages` o
+//      `max_tokens`, salvo los que van a una llamada de OpenAI (`chat.completions.create(`, `responses.create(`).
+// Se avisa solo si el modelo del pedido se puede leer y es uno de los afectados, y si el parámetro es un número fuera
+// de lo aceptado. El modelo se lee si es un literal, una constante asignada una sola vez en el archivo o el valor por
+// defecto de una variable (`process.env.X || '…'`, `os.getenv("X", "…")`). Si no se puede saber, no se avisa (D64).
+//
+// API version `2026-10-21` (D65): elimina los tres parámetros para cualquier modelo (400 aunque tengan su valor por
+// defecto). La manda el archivo (`anthropic-version: 2026-10-21`) o el SDK desde su versión mayor nueva (TypeScript 1.0.0
+// y Python 2.0.0, del 21/10/2026); los anteriores mandan `2023-06-01`. Corre sobre los mismos pedidos, sin importar el
+// modelo, si el archivo es de Anthropic (importa el SDK, nombra un `claude-…` o va por HTTP a api.anthropic.com), y dice
+// si ya falla (header, SDK instalado o, en Python, `TypeError` desde la 1.0), si falla en una instalación nueva (rango
+// sin tope) o si va a fallar cuando suban el SDK. Lo que ya avisó la regla de Claude 4.7 no se repite. Por HTTP sin el
+// header nuevo no se avisa: la versión la elige el archivo y no cambia sola.
+import { openRange } from '../context.js';
+
+const PACK = 'ai.model-retirements';
+const JS = /\.[cm]?[jt]sx?$/i;
+const PY = /\.py$/i;
+const PARAMS = ['temperature', 'top_p', 'top_k'];
+const MESSAGES_CALL = /\.\s*messages\s*\.\s*(?:with_(?:raw|streaming)_response\s*\.\s*)?(?:create|stream)\s*$/;
+const OPENAI_CALL = /\.\s*(?:chat\s*\.\s*)?completions\s*\.\s*create\s*$|\.\s*responses\s*\.\s*(?:create|stream|parse)\s*$/;
+const TYPED_PARAMS = /MessageCreateParams\w*(?:<[^>]*>)?\s*=\s*$/;
+const NUMBER = /^(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
+const IDENT = /^[A-Za-z_$][\w$]*$/;
+const NAMES = /[A-Za-z_$][\w$]*/g;
+// Antes de una `/` que abre una regex de JS (y no es una división) hay un operador, un separador o una palabra clave.
+const REGEX_BEFORE = /(?:^|[(,=:[!&|?{};+\-*%<>~^]|\b(?:return|typeof|case|in|of|yield|await|void|delete|throw|else|do))\s*$/;
+const CONTROL = /\b(?:if|for|while|switch|catch|with)\s*$/;
+const ANTHROPIC = /@anthropic-ai\/|["'`]claude-|^\s*(?:from\s+anthropic(?:\.\w+)*\s+import|import\s+anthropic)\b/m;
+const TS = /\.[cm]?tsx?$/i;
+const EMPTY = /^(?:undefined|null|None)$/;
+
+// a ≥ b, comparando "mayor.menor.parche".
+const atLeast = (a, b) => {
+  const x = String(a).split('.').map(Number);
+  const y = String(b).split('.').map(Number);
+  for (let i = 0; i < 3; i++) if ((x[i] || 0) !== (y[i] || 0)) return (x[i] || 0) > (y[i] || 0);
+  return true;
+};
+
+// Copia del código con los comentarios y el interior de los strings en blanco (mismas posiciones y saltos de línea),
+// para buscar llaves, comas y claves sin tropezar con texto. Los strings quedan aparte, con su valor.
+function tokenize(source, python) {
+  const code = source.split('');
+  const strings = [];
+  const blank = (a, b) => { for (let k = a; k < b; k++) if (code[k] !== '\n' && code[k] !== '\r') code[k] = ' '; };
+  const n = source.length;
+  let i = 0;
+  while (i < n) {
+    const c = source[i];
+    if (python ? c === '#' : source.startsWith('//', i)) {
+      const e = source.indexOf('\n', i);
+      const end = e < 0 ? n : e;
+      blank(i, end); i = end; continue;
+    }
+    if (!python && source.startsWith('/*', i)) {
+      const e = source.indexOf('*/', i + 2);
+      const end = e < 0 ? n : e + 2;
+      blank(i, end); i = end; continue;
+    }
+    if (c === '"' || c === "'" || (c === '`' && !python)) {
+      const q = python && source.startsWith(c.repeat(3), i) ? c.repeat(3) : c;
+      let j = i + q.length;
+      while (j < n && !source.startsWith(q, j)) {
+        if (source[j] === '\\') j++;
+        else if (source[j] === '\n' && q.length === 1 && c !== '`') break; // string sin cerrar: termina en la línea
+        j++;
+      }
+      const end = Math.min(n, j + q.length);
+      strings.push({ start: i, end, value: source.slice(i + q.length, j) });
+      blank(i + q.length, j);
+      i = end; continue;
+    }
+    if (!python && c === '/' && REGEX_BEFORE.test(code.slice(Math.max(0, i - 12), i).join(''))) {
+      let j = i + 1;
+      let inClass = false;
+      while (j < n && source[j] !== '\n' && (inClass || source[j] !== '/')) {
+        if (source[j] === '\\') j++;
+        else if (source[j] === '[') inClass = true;
+        else if (source[j] === ']') inClass = false;
+        j++;
+      }
+      blank(i + 1, j);
+      i = j + 1; continue;
+    }
+    i++;
+  }
+  return { code: code.join(''), strings };
+}
+
+// Árbol de paréntesis, corchetes y llaves, y la profundidad de cada posición. Un cierre que no corresponde al último
+// abierto cierra hasta su par (código a medio escribir o una regex que no se reconoció); si no tiene par, se ignora.
+function brackets(code) {
+  const PAIR = { ')': '(', ']': '[', '}': '{' };
+  const nodes = [];
+  const stack = [];
+  const depth = new Uint16Array(code.length + 1);
+  for (let i = 0; i < code.length; i++) {
+    const c = code[i];
+    depth[i] = stack.length;
+    if (c === '(' || c === '[' || c === '{') {
+      const node = { open: c, start: i, end: -1, parent: stack.at(-1) || null };
+      stack.push(node);
+      nodes.push(node);
+    } else if (PAIR[c]) {
+      const k = stack.map((x) => x.open).lastIndexOf(PAIR[c]);
+      if (k < 0) continue;
+      for (const x of stack.splice(k)) x.end = i;
+    }
+  }
+  return { nodes: nodes.filter((x) => x.end >= 0), depth };
+}
+
+// Primer separador de primer nivel en code[a, b): `:` en objetos y diccionarios, `=` en argumentos con nombre de Python
+// (no `==`, `<=`, `>=`, `!=`).
+function separator(code, a, b, sep) {
+  let level = 0;
+  for (let i = a; i < b; i++) {
+    const c = code[i];
+    if ('([{'.includes(c)) level++;
+    else if (')]}'.includes(c)) level--;
+    else if (level === 0 && c === sep) {
+      if (sep === '=' && (code[i + 1] === '=' || '=!<>'.includes(code[i - 1]))) continue;
+      return i;
+    }
+  }
+  return -1;
+}
+
+export default function detectSamplingParams({ source, file, pack, context }) {
+  const rules = pack.detect.sampling_params;
+  const python = PY.test(file);
+  if (!rules || (!python && !JS.test(file))) return { findings: [], usages: [] };
+  // La mayoría de los archivos no tiene el parámetro, ni un modelo afectado ni nada de Anthropic: no hace falta
+  // tokenizarlos.
+  const api = rules.api_version;
+  const anthropic = Boolean(api) && (ANTHROPIC.test(source) || (/api\.anthropic\.com/.test(source) && /v1\/messages/.test(source)));
+  if (!PARAMS.some((p) => source.includes(p)) || (!anthropic && !rules.models.some((m) => source.includes(m)))) return { findings: [], usages: [] };
+
+  const { code, strings } = tokenize(source, python);
+  const { nodes, depth } = brackets(code);
+  const stringAt = new Map(strings.map((s) => [s.start, s]));
+  const lineStarts = [0];
+  for (let i = 0; i < source.length; i++) if (source[i] === '\n') lineStarts.push(i + 1);
+  const lineOf = (pos) => {
+    let lo = 0;
+    let hi = lineStarts.length - 1;
+    while (lo < hi) { const mid = (lo + hi + 1) >> 1; if (lineStarts[mid] <= pos) lo = mid; else hi = mid - 1; }
+    return lo + 1;
+  };
+  // Texto de code[a, b) sin los espacios (ni los comentarios) de los bordes, tomado del original. Sin `as const` ni
+  // `satisfies T` de TypeScript al final.
+  const trimmed = (a, b) => {
+    while (a < b && /\s/.test(code[a])) a++;
+    while (b > a && /\s/.test(code[b - 1])) b--;
+    const cast = python ? null : code.slice(a, b).match(/\s+(?:as|satisfies)\s+[\w$.<>\[\]]+$/);
+    if (cast) b -= cast[0].length;
+    return { at: a, end: b, text: source.slice(a, b) };
+  };
+  const literal = (v) => { const s = stringAt.get(v.at); return s && s.end === v.end ? s.value : null; };
+  const before = (node) => code.slice(Math.max(0, node.start - 160), node.start);
+  const nodeAt = (pos) => nodes.find((x) => x.start === pos) || null;
+
+  // Asignaciones del archivo. Una variable cuenta como constante si se asigna una sola vez, en una declaración
+  // (`const X = …` en JS; `X = …` fuera de paréntesis en Python) y con el valor en la misma línea. Todo lo demás que
+  // le da un valor a un nombre (parámetros de funciones, desestructuración, imports, `for`, `+=`) cuenta como otra
+  // asignación: así un parámetro que se llama igual que una constante no hace leer un valor que no es.
+  let assigned = null;
+  const assignments = () => {
+    if (assigned) return assigned;
+    assigned = new Map();
+    const add = (name, at, valueAt) => {
+      const list = assigned.get(name) || [];
+      if (!list.some((x) => x.at === at)) list.push({ at, valueAt });
+      assigned.set(name, list);
+    };
+    const bind = (a, b) => { for (const m of code.slice(a, b).matchAll(NAMES)) add(m[0], a + m.index, null); };
+    if (python) {
+      for (const m of code.matchAll(/^[ \t]*([A-Za-z_]\w*)[ \t]*(?::[^=\n]*)?=(?!=)/gm)) {
+        const at = m.index + m[0].indexOf(m[1]);
+        if (depth[at] === 0) add(m[1], at, m.index + m[0].length);
+      }
+      for (const m of code.matchAll(/^[ \t]*([A-Za-z_]\w*)[ \t]*(?:[-+*/%@&|^]|\/\/|\*\*|>>|<<)=/gm)) add(m[1], m.index + m[0].indexOf(m[1]), null);
+      for (const m of code.matchAll(/^[ \t]*([\w \t*]+,[\w \t*,]*)=(?!=)/gm)) bind(m.index, m.index + m[1].length + m[0].indexOf(m[1]));
+      for (const m of code.matchAll(/\b(?:for|as|global|nonlocal)\s+([A-Za-z_]\w*)\b|\b([A-Za-z_]\w*)\s*:=/g)) add(m[1] || m[2], m.index + m[0].indexOf(m[1] || m[2]), null);
+      for (const m of code.matchAll(/^[ \t]*(?:from\s+\S+\s+)?import\s+([^\n]+)/gm)) bind(m.index + m[0].length - m[1].length, m.index + m[0].length);
+      for (const x of nodes) if (x.open === '(' && /\bdef\s+\w+\s*$/.test(before(x))) bind(x.start + 1, x.end);
+    } else {
+      for (const m of code.matchAll(/(?<![\w$.])(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*(?::[^=;\n]*)?=(?![=>])/g)) {
+        add(m[1], m.index + m[0].indexOf(m[1], m[0].search(/\s/)), m.index + m[0].length);
+      }
+      for (const m of code.matchAll(/(?<![\w$.])([A-Za-z_$][\w$]*)\s*(?:[-+*/%&|^]|\*\*|\?\?|\|\||&&|>>>?|<<)?=(?![=>])/g)) add(m[1], m.index, null);
+      for (const m of code.matchAll(/(?<![\w$.])(?:const|let|var)\s*([{[])/g)) {
+        const x = nodeAt(m.index + m[0].length - 1);
+        if (x) bind(x.start, x.end);
+      }
+      for (const m of code.matchAll(/(?<![\w$.])([A-Za-z_$][\w$]*)\s*=>/g)) add(m[1], m.index, null);
+      for (const m of code.matchAll(/^[ \t]*import\s+([^;\n]*?)\s+from\b/gm)) bind(m.index, m.index + m[0].length);
+      for (const x of nodes) {
+        if (x.open === '(' && !CONTROL.test(before(x)) && /^\s*(?::[^={;]*)?(?:=>|\{)/.test(code.slice(x.end + 1, x.end + 120))) bind(x.start + 1, x.end);
+      }
+    }
+    const lineEnd = (i) => { const e = code.indexOf('\n', i); return e < 0 ? code.length : e; };
+    for (const list of assigned.values()) {
+      for (const x of list) {
+        if (x.valueAt === null) continue;
+        let { at, end } = trimmed(x.valueAt, lineEnd(x.valueAt));
+        while (end > at && (code[end - 1] === ';' || code[end - 1] === ',' || /\s/.test(code[end - 1]))) end--;
+        x.value = trimmed(at, end);
+      }
+    }
+    return assigned;
+  };
+  const constant = (name) => {
+    const list = assignments().get(name) || [];
+    return list.length === 1 && list[0].value ? list[0].value : null;
+  };
+
+  // El modelo de un valor: literal, constante o el valor por defecto de una variable. `from` dice de dónde sale.
+  const modelOf = (v, nested = false) => {
+    const lit = literal(v);
+    if (lit !== null) return { id: lit, from: null };
+    const t = v.text;
+    if (IDENT.test(t)) { const c = !nested && constant(t); return c ? modelOf(c, true) : null; }
+    const js = !python && t.match(/^(process\.env(?:\.\w+|\[\s*(['"])\w+\2\s*\])|[A-Za-z_$][\w$]*(?:\??\.[A-Za-z_$][\w$]*)*)\s*(?:\|\||\?\?)\s*(['"`])([^'"`\\$]*)\3$/);
+    if (js) return { id: js[4], from: `\`${js[1]}\`` };
+    const env = python && t.match(/^(?:os\.)?(?:getenv|environ\.get)\(\s*(['"])(\w+)\1\s*,\s*(['"])([^'"\\]*)\3\s*\)$/);
+    if (env) return { id: env[4], from: `la variable de entorno \`${env[2]}\`` };
+    const or = python && t.match(/^([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)\s+or\s+(['"])([^'"\\]*)\2$/);
+    if (or) return { id: or[3], from: `\`${or[1]}\`` };
+    return null;
+  };
+  // El número de un valor: literal o constante. `via` es el nombre de la constante.
+  const numberOf = (v) => {
+    if (NUMBER.test(v.text)) return { value: Number(v.text), via: null };
+    const c = IDENT.test(v.text) && constant(v.text);
+    return c && NUMBER.test(c.text) ? { value: Number(c.text), via: v.text } : null;
+  };
+
+  // Entradas de primer nivel de un nodo: { key, sep, keyAt, value }. En JS, `clave: valor`, `'clave': valor` y la forma
+  // corta `{ temperature }` (sep null); en Python, `"clave": valor` en diccionarios y `clave=valor` en argumentos.
+  const entriesOf = (node) => {
+    const sep = node.open === '{' ? ':' : '=';
+    const out = [];
+    const push = (a, b) => {
+      const s = separator(code, a, b, sep);
+      if (s < 0) {
+        const v = trimmed(a, b);
+        if (!python && sep === ':' && IDENT.test(v.text)) out.push({ key: v.text, sep: null, keyAt: v.at, value: v });
+        return;
+      }
+      const k = trimmed(a, s);
+      const key = IDENT.test(k.text) ? k.text : literal(k);
+      if (key !== null) out.push({ key, sep, keyAt: k.at, value: trimmed(s + 1, b) });
+    };
+    let level = 0;
+    let a = node.start + 1;
+    for (let i = node.start + 1; i < node.end; i++) {
+      const c = code[i];
+      if ('([{'.includes(c)) level++;
+      else if (')]}'.includes(c)) level--;
+      else if (c === ',' && level === 0) { push(a, i); a = i + 1; }
+    }
+    push(a, node.end);
+    return out;
+  };
+
+  // Los pedidos: nodo → 'sdk' o 'http'.
+  const requests = new Map();
+  const paramVars = new Set();
+  for (const call of nodes.filter((x) => x.open === '(' && MESSAGES_CALL.test(before(x)))) {
+    const comma = separator(code, call.start + 1, call.end, ',');
+    const first = trimmed(call.start + 1, comma < 0 ? call.end : comma);
+    if (python) requests.set(call, 'sdk');
+    else if (code[first.at] === '{') requests.set(nodeAt(first.at), 'sdk');
+    const name = first.text.replace(/^\*\*/, '');
+    if (IDENT.test(name)) paramVars.add(name);
+  }
+  const http = /api\.anthropic\.com/.test(source) && /v1\/messages/.test(source);
+  for (const node of nodes) {
+    if (node.open !== '{' || requests.has(node)) continue;
+    const head = before(node);
+    const target = head.match(/(?<![\w$.])([A-Za-z_$][\w$]*)\s*(?::[^=;\n]*)?=\s*$/);
+    if ((target && paramVars.has(target[1])) || TYPED_PARAMS.test(head)) { requests.set(node, 'sdk'); continue; }
+    if (!http) continue;
+    let openai = false;
+    for (let p = node.parent; p && !openai; p = p.parent) openai = p.open === '(' && OPENAI_CALL.test(before(p));
+    if (!openai) requests.set(node, 'http');
+  }
+
+  const findings = [];
+  const usages = [];
+  const report = (at, message, op) => {
+    findings.push({ pack: PACK, file, line: lineOf(at), status: 'detect-only', message });
+    usages.push({ provider: 'ia', op, line: lineOf(at) });
+  };
+  const shownOf = (param, e) => (e.sep === '=' ? `${param}=${e.value.text}` : e.sep ? `${param}: ${e.value.text}` : param);
+
+  // API version `2026-10-21`: la que manda el archivo (`new`, `old` o null si no la nombra) y el SDK instalado.
+  const header = (() => {
+    if (!anthropic || !strings.some((s) => s.value.toLowerCase() === 'anthropic-version')) return null;
+    if (strings.some((s) => s.value === api.version)) return 'new';
+    return strings.some((s) => /^2023-0[16]-01$/.test(s.value)) ? 'old' : null;
+  })();
+  const sdk = api?.sdks[python ? 'pypi' : 'npm'];
+  const installed = sdk ? context?.versions?.[python ? 'pypi' : 'npm']?.[sdk.package] || null : null;
+  const whereOf = (v) => (v.source === 'declarada' ? `declarado como \`${v.range}\`` : v.source === 'node_modules' ? 'instalado en node_modules' : `según ${v.source}`);
+  const cap = (s) => s[0].toUpperCase() + s.slice(1);
+  const apiVersion = (via, byKey, model, flagged) => {
+    // Un archivo que fija `2023-06-01` eligió quedarse; por HTTP, la versión la elige el archivo.
+    if (!anthropic || header === 'old' || (via === 'http' && header !== 'new')) return;
+    const usable = (e) => !EMPTY.test(e.value.text);
+    const candidates = PARAMS.filter((p) => byKey.has(p) && !flagged.has(p) && usable(byKey.get(p))).map((param) => ({ param, e: byKey.get(param), extra: false }));
+    // Python: lo que va en `extra_body={...}` llega a la API sin pasar por la firma del método.
+    const xb = python && byKey.get('extra_body');
+    const xn = xb && code[xb.value.at] === '{' ? nodeAt(xb.value.at) : null;
+    if (xn) for (const e of entriesOf(xn)) if (PARAMS.includes(e.key) && !flagged.has(e.key) && usable(e)) candidates.push({ param: e.key, e, extra: true });
+    const older = model && api.older_models.some((m) => model.id.startsWith(m)) ? model.id : null;
+    const pkg = `\`${sdk.package}\``;
+    for (const { param, e, extra } of candidates) {
+      // En Python, un parámetro directo falla antes de llegar a la API: el SDK 1.0 lo sacó de la firma.
+      const direct = python && !extra && via === 'sdk';
+      const target = direct ? sdk.typeerror_from : sdk.first;
+      const reason = direct
+        ? `desde la ${sdk.typeerror_from}, el SDK de Python ya no tiene \`temperature\`, \`top_p\` ni \`top_k\` y pasarlos tira \`TypeError\` con cualquier modelo`
+        : `desde la ${sdk.first}, el SDK usa la API version \`${api.version}\`, y ${api.removed_es}`;
+      const rec = api.recommendation_es.replace('{param}', `\`${param}\``);
+      const shown = `\`${shownOf(param, e)}\`${extra ? ' (en `extra_body`)' : ''}`;
+      let message;
+      if (header === 'new') {
+        message = `${shown} ya no funciona: el archivo manda \`anthropic-version: ${api.version}\`, y ${api.removed_es}. ${cap(rec)}.`;
+      } else if (installed && atLeast(installed.version, target)) {
+        message = `${shown} ya no funciona con ${pkg} ${installed.version} (${whereOf(installed)}): ${reason}.`
+          + (direct && !atLeast(installed.version, sdk.first) ? ` Tampoco sirve pasarlo por \`extra_body\`: con la ${sdk.first} (del ${api.released_es}) devuelve un error 400.` : '')
+          + ` ${cap(rec)}.`;
+      } else if (installed?.source === 'declarada' && openRange(installed.range)) {
+        message = `${shown} falla en una instalación nueva: ${pkg} está declarado como \`${installed.range}\`, que ya deja instalar la ${sdk.first} (del ${api.released_es}). ${cap(reason)}. ${cap(rec)}, o fijá el SDK debajo de la ${target}.`;
+      } else {
+        const when = `${target}${target === sdk.first ? ` (del ${api.released_es})` : ''}`;
+        const alsoExtra = direct ? ` Y desde la ${sdk.first} (del ${api.released_es}) tampoco sirve pasarlo por \`extra_body\`: la API version \`${api.version}\` lo rechaza.` : '';
+        // Sin la versión no se puede decir que hoy funciona: puede que ya falle.
+        message = installed
+          ? `${shown} funciona con ${pkg} ${installed.version} (${whereOf(installed)}), pero va a fallar cuando lo subas a la ${when}: ${reason}.${alsoExtra} Antes de aceptar esa suba, ${rec}.`
+          : `${shown} falla con ${pkg} ${target} o posterior: ${reason}.${alsoExtra} Parche no encontró qué versión del SDK usa este repo: si ya es la ${target} o una posterior, el pedido ya falla. ${cap(rec)}.`;
+      }
+      if (!python && via === 'sdk' && header !== 'new' && TS.test(file)) message += ` ${api.typescript_es}`;
+      if (param === 'temperature' && NUMBER.test(e.value.text) && Number(e.value.text) === 0) message += ` ${rules.temperature_zero_es}`;
+      if (older) message += ` ${api.older_model_es.replace('{model}', `\`${older}\``)}`;
+      report(e.keyAt, message, `Anthropic ${param} (API version ${api.version})`);
+    }
+  };
+
+  for (const [node, via] of requests) {
+    if (!node) continue;
+    const byKey = new Map(entriesOf(node).map((e) => [e.key, e]));
+    if (via === 'http' && !byKey.has('messages') && !byKey.has('max_tokens')) continue;
+    const model = byKey.has('model') ? modelOf(byKey.get('model').value) : null;
+    const flagged = new Set(); // lo que ya avisó la regla de Claude 4.7: no se repite
+    if (model && rules.models.includes(model.id)) claude47(byKey, via, model, flagged);
+    apiVersion(via, byKey, model, flagged);
+  }
+  // Los pedidos salen en el orden del árbol (de afuera hacia adentro); el reporte va en el orden del archivo.
+  const byLine = (a, b) => a.line - b.line;
+  return { findings: findings.sort(byLine), usages: usages.sort(byLine) };
+
+  // Claude 4.7 y posteriores: el parámetro con un valor fuera de lo aceptado (y, en Haiku 5.5, los dos juntos).
+  function claude47(byKey, via, model, flagged) {
+    const override = rules.overrides?.[model.id] || {};
+    const scope = override.scope_es || rules.scope_es;
+    const accepted = { ...rules.accepted, ...override.accepted };
+    const modelText = `\`${model.id}\`${model.from ? ` (el valor por defecto de ${model.from})` : ''}`;
+    const tail = (params, zero) => `Recomendación oficial de Anthropic: ${rules.recommendation_es.replace('{params}', params.map((p) => `\`${p}\``).join(' y '))}.`
+      + (zero ? ` ${rules.temperature_zero_es}` : '') + (python && via === 'sdk' ? ` ${rules.python_sdk_es}` : '');
+    const present = [];
+    for (const param of PARAMS) {
+      const e = byKey.get(param);
+      const num = e && numberOf(e.value);
+      if (!num) continue;
+      present.push({ param, e });
+      const ok = accepted[param];
+      if (ok.min !== undefined && num.value >= ok.min && num.value <= ok.max) continue;
+      flagged.add(param);
+      const shown = shownOf(param, e) + (num.via ? ` (${num.value})` : '');
+      report(e.keyAt, `\`${shown}\` con el modelo ${modelText} da un error 400: ${scope}, \`${param}\` ${ok.es}. ${tail([param], param === 'temperature' && num.value === 0)}`,
+        `Anthropic ${param} (Claude 4.7+)`);
+    }
+    const together = override.exclusive || [];
+    if (together.length && !flagged.size && together.every((p) => present.some((x) => x.param === p))) {
+      const last = present.filter((x) => together.includes(x.param)).at(-1);
+      report(last.e.keyAt, `${together.map((p) => `\`${p}\``).join(' y ')} juntos con el modelo ${modelText} dan un error 400: ${override.exclusive_es}. ${tail(together, false)}`,
+        `Anthropic ${together.join(' + ')} (Claude 4.7+)`);
+      for (const p of together) flagged.add(p);
+    }
+  }
+}

package/src/report.js

@@ -102,7 +102,9 @@ export function partialCovers(findings) {
   return [...new Set(findings.filter((f) => f.partial).map((f) => f.partial.covers))];
 }
 
-export function prBody({ pack, findings, changed, verification }, today = new Date()) {
+// `ciApproval`: el PR lo abre GitHub Actions con el GITHUB_TOKEN por defecto. GitHub deja los workflows de ese PR
+// esperando aprobación (docs de GitHub, "GITHUB_TOKEN"): sin avisarlo, el PR parece roto.
+export function prBody({ pack, findings, changed, verification, ciApproval = false }, today = new Date()) {
   const fs = findings.filter((f) => f.pack === pack.id);
   const c = counts(fs);
   const out = [];
@@ -152,10 +154,13 @@ export function prBody({ pack, findings, changed, verification }, today = new Da
     } else {
       out.push('- Sin verificar (corré `parche pr --verify`).');
     }
+    if (ciApproval) {
+      out.push('- CI de este PR: lo abrió GitHub Actions con el `GITHUB_TOKEN`, así que GitHub deja sus workflows esperando aprobación. Alguien con permiso de escritura tiene que tocar **Approve workflows to run**. Para que corran solos, pasale a la Action un token de una GitHub App o un token personal (input `token`).');
+    }
   }
   out.push('', asIssue ? '### Checklist' : '### Checklist antes de mergear', '', ...pack.review_checklist_es.map((x) => `- [ ] ${x}`), '');
   out.push('### Fuentes', '', ...pack.sources.map((s) => `- [${s.title}](${s.url})`), '');
-  out.push(`<sub>Pack \`${pack.id}\` v${pack.version}, verificado el ${pack.last_verified}. Resumen: ${Object.entries(c).map(([k, v]) => `${LABEL[k]} ${v}`).join(' · ')}. ¿Este PR te sirvió? Mergealo, editalo o cerralo: Parche aprende de cada resultado.</sub>`, '');
+  out.push(`<sub>Pack \`${pack.id}\` v${pack.version}, verificado el ${pack.last_verified}. Resumen: ${Object.entries(c).map(([k, v]) => `${LABEL[k]} ${v}`).join(' · ')}. ¿Este PR te sirvió? Mergealo, editalo o cerralo: Parche aprende de cada resultado. [¿Qué es Parche y por qué recibiste esto?](https://github.com/Pepo08/parche/blob/main/docs/por-que-recibi-este-pr.md)</sub>`, '');
   return out.join('\n');
 }
 

package/templates/github-workflow.yml

@@ -8,20 +8,25 @@ on:
     - cron: "17 11 * * 1" # lunes 8:17 (hora de Argentina)
   workflow_dispatch:
 
+# Por defecto, solo lectura. La escritura la pide el único job que la necesita.
 permissions:
-  contents: write
-  pull-requests: write
+  contents: read
 
 jobs:
   parche:
     runs-on: ubuntu-latest
+    permissions:
+      contents: write # pushear la rama parche/<pack>
+      pull-requests: write # abrir el PR
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           fetch-depth: 0
-      - uses: actions/setup-node@v7
+      - uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0
         with:
           node-version: 24
       - name: Instalar dependencias del proyecto (para correr sus tests antes de cada PR)
         run: npm ci
+      # v0 se mueve con cada release 0.x. Para fijar una versión, cambiá v0 por el commit de ese release
+      # (https://github.com/Pepo08/parche/releases), por ejemplo: Pepo08/parche@<sha> # v0.6.7
       - uses: Pepo08/parche@v0