parche-cli 0.5.1 → 0.6.1

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 Todas las versiones de `parche-cli` (npm) y de la Action `Pepo08/parche@v0`.
 
+## 0.6.1 — 2026-10-18
+
+Lo que encontró el frente de tracción al preparar los PRs con la 0.6.0.
+
+### Arreglado
+- **ARCA en JS: si el objeto recibe el campo después, cuenta como migrado**, igual que en PHP: `voucher.CondicionIVAReceptorId = …`, `voucher['CondicionIVAReceptorId'] = …`, con cast de TS u `Object.assign(voucher, { CondicionIVAReceptorId: … })`. Antes se agregaba el arreglo parcial igual, y era redundante. Una variable con el mismo nombre en otra función no cuenta.
+- **Copias de respaldo:** no se leen ni se editan las carpetas `BAK/`, `backup(s)/`, `old/`, `_old/` y `deprecated/`, ni los archivos `* copy.*`, `* - Copy.*`, `* copia.*`, `*.bak.*`, `*-old.*`, `*_old.*` y `*.old.*`. Tampoco cuentan sus manifiestos ni sus WSDL. El scan y `report.md` dicen qué se saltó.
+- **Windows:** los comandos de git corren con `core.longpaths`. Sin eso, un clon recién hecho con rutas largas daba "Hay cambios sin commitear".
+- **`parche pr --author "Nombre <email>"`** firma con esa identidad sin tocar la configuración de git. `pr` muestra quién firma y, antes de pushear, avisa si el email no es un noreply de GitHub (queda público en el PR).
+- Si solo cambiarían tests o mocks, el texto queda como issue: ya no empieza con "Modifica 1 archivo".
+- La consola ya no repite "No cubre: No cubre…" en los arreglos parciales.
+
+## 0.6.0 — 2026-10-17
+
+### Nuevo
+- **ARCA con `DocTipo` en una variable: PR parcial (consumidor final).** Antes se reportaba como "falta un dato" y no se tocaba nada. Ahora Parche aplica la regla 99 → 5 **al ejecutarse** y, con otro `DocTipo`, el pedido sale igual que hoy (la clave ni existe). En JS agrega `...(Number(docTipo) === 99 ? { CondicionIVAReceptorId: 5 } : {})`; en PHP, un `if ((int) $data['DocTipo'] === 99)` después de armar el array, nunca `null`. El PR sale borrador, con "(parcial: consumidor final)" en el título y, en "Lo que este PR NO resuelve", los casos que no cubre con los códigos válidos. No se aplica a facturas A, a expresiones con efectos (llamadas, `await`) ni a arrays de PHP dentro de la llamada. Si se corre de nuevo después del merge, no cambia nada y sigue avisando lo que falta.
+- El ledger registra cuántos arreglos parciales lleva cada PR (`partial`).
+
+### Arreglado
+- ARCA en JS: la clave nueva usa las mismas comillas que las claves del objeto. Antes copiaba las del resto del archivo y, en un repo real con claves `'...'` en un archivo con `"..."`, quedaba distinta a sus vecinas.
+
 ## 0.5.1 — 2026-10-17
 
 Lo que apareció en el primer PR real (lunamarie11/obraya#1).

package/README.md

@@ -129,7 +129,7 @@ Con el tag, el workflow corre los tests, controla que la versión de `package.js
 
 | Pack | Proveedor | Tipo | Fecha límite | Arreglo |
 |---|---|---|---|---|
-| `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 |
+| `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 |
 
@@ -137,7 +137,9 @@ Con el tag, el workflow corre los tests, controla que la versión de `package.js
 
 Antes de commitear, Parche parsea **siempre** cada archivo modificado (JS/TS o PHP): eso no ejecuta nada del repo. Con `--verify`, además corre los tests del repo que correspondan a lo que cambió: `npm test` para JS/TS; para PHP, `composer test` o `vendor/bin/phpunit`. Si no hay tests, queda el chequeo de sintaxis y el PR lo dice. Sin `--verify` (por ejemplo, en un PR a un repo de terceros, donde no se ejecuta su código), el PR dice que Parche no corrió los tests y nombra los workflows del repo que los corren en cada pull request. Si algo falla, no hay PR. El commit lleva la versión del pack que lo generó, para poder rastrear qué regla produjo cada cambio.
 
-**Quién firma el commit:** `PARCHE_GIT_NAME` y `PARCHE_GIT_EMAIL` si están; si no, tu identidad de git (`user.name` y `user.email`, también la que configure tu workflow); en GitHub Actions sin identidad, `github-actions[bot]`, el mismo que abre el PR. Si no hay ninguna, `parche pr` frena antes de tocar el repo.
+**Quién firma el commit:** `--author "Nombre <email>"` si lo pasás; si no, `PARCHE_GIT_NAME` y `PARCHE_GIT_EMAIL` si están; si no, tu identidad de git (`user.name` y `user.email`, también la que configure tu workflow); en GitHub Actions sin identidad, `github-actions[bot]`, el mismo que abre el PR. Si no hay ninguna, `parche pr` frena antes de tocar el repo. Antes de pushear, si el email no es un noreply de GitHub, avisa: va a quedar público en el commit del PR.
+
+**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.
 
 ## ARCA en PHP
 
@@ -157,6 +159,31 @@ Para `afipsdk/afip.php` y sus forks (`fertandil87/afip.php`, `ivanalemunioz/afip
 
 **Otros lenguajes:** en Python, C#, Java, Go y VB.NET, Parche detecta integraciones SOAP propias y clientes SOAP generados sin el campo (no los reescribe).
 
+## ARCA con `DocTipo` en una variable: PR parcial
+
+Cuando `DocTipo` no es un número fijo (`DocTipo: docTipo`), Parche no puede saber la condición frente al IVA de cada cliente. Lo único que se sabe sin datos del negocio es que **99 (consumidor final sin identificar) va con 5**, así que aplica esa regla **al ejecutarse** y, con cualquier otro `DocTipo`, el pedido sale exactamente igual que hoy:
+
+```js
+    DocNro: docNro,
+    // parche: 5 = Consumidor Final solo si DocTipo es 99; con otro DocTipo falta la condición frente al IVA del cliente
+    ...(Number(docTipo) === 99 ? { CondicionIVAReceptorId: 5 } : {}),
+```
+
+```php
+        );
+        // parche: 5 = Consumidor Final solo si DocTipo es 99; con otro DocTipo falta la condición frente al IVA del cliente
+        if ((int) $data['DocTipo'] === 99) {
+            $data['CondicionIVAReceptorId'] = 5;
+        }
+```
+
+- El PR sale **borrador**, con "(parcial: consumidor final)" en el título. En "Lo que este PR NO resuelve" dice qué falta: los comprobantes con otro `DocTipo` (CUIT, DNI y otros) siguen sin el campo y desde el 1/12/2026 ARCA los va a rechazar. Ahí también están los códigos válidos para la clase del comprobante.
+- Con otro `DocTipo` la clave ni existe (no queda en `undefined` ni en `null`): el pedido no depende de cómo lo serialice la librería y no aparece un rechazo que hoy no existe.
+- `Number(...)` y `(int)` hacen que `'99'` como texto también cuente.
+- En JS solo se aplica si `DocTipo` se puede releer sin efectos (`docTipo`, `cliente.docTipo`, `this.datos['DocTipo']`), no si es una llamada o un `await`. En PHP se lee del array ya armado, así que sirve cualquier expresión, pero el array tiene que estar en una variable (`$data = [...]`): con el array dentro de la llamada no hay dónde poner el `if`.
+- No se aplica a facturas A ni a otras clases conocidas que no sean B o C.
+- Si se vuelve a correr después del merge, no cambia nada y sigue avisando lo que falta.
+
 ## Límites del MVP
 
 - JS/TS (ESM y CommonJS) y, para ARCA, PHP. Siguen Python y Java.

package/bin/parche.js

@@ -4,7 +4,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { run } from '../src/engine.js';
 import { loadPacks } from '../src/packs.js';
-import { scanReport, prBody, counts, LABEL, daysUntil } from '../src/report.js';
+import { scanReport, prBody, counts, LABEL, daysUntil, partialCovers } from '../src/report.js';
 import { verify } from '../src/verify.js';
 import * as git from '../src/git.js';
 import { parseGithubRemote, openPullRequest } from '../src/github.js';
@@ -22,9 +22,10 @@ Uso:
   parche diff <paquete> --from <v> --to <v> [--json] [--all]
                                        Qué cambia en la API de un paquete de npm entre dos versiones
   parche fix <dir> [--pack <id>]       Aplica los arreglos en el código
-  parche pr <dir> [--pack <id>] [--dry-run] [--verify] [--push-remote <remote>]
+  parche pr <dir> [--pack <id>] [--dry-run] [--verify] [--push-remote <remote>] [--author "Nombre <email>"]
                                        Rama + commit + PR por cada cambio. Con --push-remote,
-                                       pushea a ese remote (tu fork) y abre el PR contra origin
+                                       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 "..."]
 `;
 
@@ -115,13 +116,24 @@ function printDiff(d, { all = false } = {}) {
   }
 }
 
+// Lo que no se revisó por ser copia de respaldo: se dice, no se oculta.
+function printSkipped(skipped = []) {
+  if (!skipped.length) return;
+  const shown = skipped.slice(0, 8).join(', ');
+  console.log(`\nNo revisé ${skipped.length} copia(s) de respaldo: ${shown}${skipped.length > 8 ? ` y ${skipped.length - 8} más` : ''}. Si alguna es código que corre, renombrala o movela.`);
+}
+
 function printFindings(result) {
   for (const pack of result.packs) {
     const fs2 = result.findings.filter((f) => f.pack === pack.id);
     if (!fs2.length) continue;
     const d = pack.deadline ? ` · vence ${pack.deadline} (${daysUntil(pack.deadline)} días)` : '';
     console.log(`\n■ ${pack.title}\n  ${pack.provider} · severidad ${pack.severity}${d}`);
-    for (const f of fs2) console.log(`  ${LABEL[f.status].padEnd(16)} ${f.file}${f.line ? ':' + f.line : ''}  ${f.message}`);
+    for (const f of fs2) {
+      console.log(`  ${LABEL[f.status].padEnd(16)} ${f.file}${f.line ? ':' + f.line : ''}  ${f.message}`);
+      // partial.message ya empieza con "No cubre…": sin prefijo (antes salía "No cubre: No cubre").
+      if (f.partial) console.log(`  ${''.padEnd(16)} ${f.partial.message}`);
+    }
   }
 }
 
@@ -168,11 +180,12 @@ async function main() {
     fs.writeFileSync(path.join(root, '.parche', 'inventory.json'), JSON.stringify(result.inventory, null, 2));
     fs.writeFileSync(path.join(root, '.parche', 'report.md'), scanReport({ ...result, changed: [], upgrades }));
     record(root, { type: 'scan', findings: counts(result.findings) });
-    if (args.json) { console.log(JSON.stringify({ inventory: result.inventory, findings: result.findings }, null, 2)); return 0; }
+    if (args.json) { console.log(JSON.stringify({ inventory: result.inventory, findings: result.findings, skipped: result.skipped }, null, 2)); return 0; }
     console.log(`Parche · scan de ${path.basename(root)}\n`);
     printInventory(result.inventory);
     if (upgrades) printUpgrades(upgrades);
     printFindings(result);
+    printSkipped(result.skipped);
     const s = summary(result.findings);
     console.log(s ? `\n${s}` : '\nNinguno de los packs verificados tiene cambios que te afecten hoy.');
     console.log(`Reporte: ${path.join(root, '.parche', 'report.md')}`);
@@ -194,7 +207,13 @@ async function main() {
     if (!git.isRepo(root)) throw new Error('`parche pr` necesita un repositorio git.');
     if (!git.isClean(root)) throw new Error('Hay cambios sin commitear. Commiteá o guardá (stash) antes de correr `parche pr`.');
     // Quién firma el commit se resuelve antes de escribir nada: si falla al commitear, el repo quedaría sucio.
-    git.commitIdentity(root);
+    const env = args.author !== undefined ? { ...process.env, ...git.parseAuthor(args.author) } : process.env;
+    const identity = git.commitIdentity(root, env);
+    console.log(`Firma los commits: ${identity.name} <${identity.email}>`);
+    // El email queda público en el PR: si no es un noreply de GitHub, se avisa antes de pushear (frente B, punto 20).
+    if (!args['dry-run'] && process.env.GITHUB_TOKEN && process.env.GITHUB_ACTIONS !== 'true' && !git.isNoreply(identity.email)) {
+      console.warn(`Ojo: ${identity.email} va a quedar público en el commit del PR. Si preferís no mostrarlo, usá --author "Nombre <usuario@users.noreply.github.com>".`);
+    }
     ensureLocalDir(root);
     const base = git.currentBranch(root);
     const packs = loadPacks().filter((p) => p.codemod && (!packIds || packIds.includes(p.id)));
@@ -204,7 +223,9 @@ async function main() {
       const preview = run(root, { write: false, packIds: [pack.id] });
       if (!preview.findings.length) continue;
       const branch = `parche/${pack.id}`;
-      const title = `Parche: ${pack.title}`;
+      // Un arreglo parcial lo dice en el título: "(parcial: consumidor final)".
+      const covers = partialCovers(preview.findings);
+      const title = `Parche: ${pack.title}${covers.length ? ` (parcial: ${covers.join(', ')})` : ''}`;
       git.checkoutNewBranch(root, branch, base);
       let keepBranch = false;
       try {
@@ -220,8 +241,10 @@ async function main() {
           git.discardChanges(root);
           throw new Error(`La verificación falló para ${pack.id}; no se abre el PR y el repo queda como estaba.\n${JSON.stringify(verification, null, 2)}`);
         }
-        fs.writeFileSync(bodyPath, prBody({ pack, findings: result.findings, changed: result.changed, verification }));
-        if (!changedFiles.length || changedFiles.every(isTestFile)) {
+        // 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 }));
+        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);
           console.log(`  ${summary(result.findings)}`);
@@ -230,7 +253,7 @@ async function main() {
           continue;
         }
         const draft = !!(c['needs-review'] || c['needs-input'] || c.blocked);
-        const sha = git.commitAll(root, `${title}\n\n${pack.summary_es}\nPack ${pack.id} v${pack.version}.`);
+        const sha = git.commitAll(root, `${title}\n\n${pack.summary_es}\nPack ${pack.id} v${pack.version}.`, env);
         keepBranch = true;
         console.log(`  Rama ${branch} · commit ${sha} · ${changedFiles.length} archivo(s)${verification ? ` · verificación ${verification.ok ? 'OK' : 'FALLÓ'}` : ''}`);
         console.log(`  ${summary(result.findings)}`);
@@ -246,7 +269,8 @@ async function main() {
         } else {
           console.log(`  Modo prueba: no se abrió el PR${draft ? ' (iría como borrador por tener ítems para revisar)' : ''}.`);
         }
-        record(root, { type: 'pr', pack: pack.id, packVersion: pack.version, branch, sha, url, draft, files: changedFiles, findings: c });
+        record(root, { type: 'pr', pack: pack.id, packVersion: pack.version, branch, sha, url, draft, files: changedFiles, findings: c,
+          partial: result.findings.filter((f) => f.partial).length });
       } finally {
         // Pase lo que pase, se vuelve a la rama base; la rama de Parche solo queda si tiene un commit.
         git.checkout(root, base);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parche-cli",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "description": "Dependabot para APIs: detecta cambios de APIs de terceros en tu código y abre el PR con el arreglo.",
   "keywords": [
     "api",

package/src/codemods/arca-rules.js

@@ -48,6 +48,37 @@ export function appliedMessage(status) {
     : 'Agregado CondicionIVAReceptorId: 5 por inferencia (DNI + comprobante B/C). Confirmá que el cliente no sea exento ni no alcanzado.';
 }
 
+// Arreglo parcial "en tiempo de ejecución" (punto 7 del frente B, 16/10): si DocTipo no es un literal
+// (DocTipo: docTipo), la regla 99 → 5 se aplica al ejecutarse y, con otro DocTipo, el pedido sale igual que hoy.
+// No inventa nada: Consumidor Final es el único caso que no depende de datos del negocio. No se aplica si el
+// comprobante es clase A o de otra clase conocida (99 con factura A no existe).
+export const PARTIAL = 'consumidor final';
+export const PARTIAL_COMMENT = ' parche: 5 = Consumidor Final solo si DocTipo es 99; con otro DocTipo falta la condición frente al IVA del cliente';
+
+export function canApplyAtRuntime(decision, cbteTipo) {
+  return decision.status === 'needs-input' && (cbteTipo === undefined || decision.clase === 'B' || decision.clase === 'C');
+}
+
+const dmy = (iso) => iso.split('-').map(Number).reverse().join('/');
+
+export function partialAppliedMessage(docTipoText) {
+  return `Arreglo parcial (${PARTIAL}): CondicionIVAReceptorId: 5 solo cuando \`${docTipoText}\` vale 99 al ejecutarse. Con otro DocTipo el pedido sale igual que hoy, sin el campo.`;
+}
+
+// Lo que el arreglo parcial NO cubre: va en el cuerpo del PR como "lo que este PR no resuelve".
+export function partialPending(decision, pack, suggestion) {
+  return {
+    covers: PARTIAL,
+    message: `No cubre los comprobantes con DocTipo distinto de 99 (CUIT, DNI y otros): siguen sin CondicionIVAReceptorId y desde el ${dmy(pack.deadline)} ARCA los va a rechazar. Falta la condición frente al IVA de cada cliente${decision.clase ? ` (comprobante clase ${decision.clase})` : ''}.`,
+    suggestion,
+  };
+}
+
+// En un scan posterior (el PR parcial ya se mergeó): lo que falta se sigue reportando.
+export function partialLeftMessage(pending) {
+  return `Tiene el arreglo parcial de Parche (solo DocTipo 99 → 5). ${pending.message}`;
+}
+
 // "El repo ya usa CondicionIVAReceptorId en otro lado": prefijo para bajar a "revisar" lo que no se pudo leer
 // (en repos ya migrados, el objeto suele salir de un builder que sí pone el campo).
 export function alreadyMigratedPrefix(context) {

package/src/codemods/arca-wsfe-condicion-iva-php.js

@@ -7,6 +7,7 @@ import { eolOf, applyEdits, finding } from '../ast.js';
 import { parsePhp, walkPhp, phpLiteral, phpKey } from '../php.js';
 import {
   PACK, decideCondition, validCodesText, missingMessage, appliedMessage, soapDetection, ARCA_HINT, libraryCaveat, alreadyMigratedPrefix,
+  canApplyAtRuntime, PARTIAL_COMMENT, partialAppliedMessage, partialPending, partialLeftMessage,
 } from './arca-rules.js';
 import { emptyContext } from '../context.js';
 
@@ -31,16 +32,33 @@ function voucherMethod(call) {
   return VOUCHER_METHODS.get(method.toLowerCase());
 }
 
+// if ($data['DocTipo'] == 99) / if ((int) $data['DocTipo'] === 99): el arreglo parcial de Parche
+// (o uno igual escrito a mano). Devuelve el nombre de la variable, o null.
+function partialIfVar(test) {
+  if (!test || test.kind !== 'bin' || (test.type !== '==' && test.type !== '===')) return null;
+  const side = (n) => (n && n.kind === 'cast' ? n.expr : n);
+  const isDocTipo = (n) => n && n.kind === 'offsetlookup' && n.what?.kind === 'variable' && typeof n.what.name === 'string'
+    && n.offset && phpLiteral(n.offset) === 'DocTipo';
+  const [a, b] = [side(test.left), side(test.right)];
+  const lookup = isDocTipo(a) ? a : isDocTipo(b) ? b : null;
+  const other = lookup === a ? b : a;
+  return lookup && phpLiteral(other) === 99 ? lookup.what.name : null;
+}
+
 // Asignaciones por scope: $var = ... y $var['Clave'] = ...
 function collect(ast) {
   const scopes = new Map();
   const calls = [];
   const info = (scope) => {
-    if (!scopes.has(scope)) scopes.set(scope, { assigns: new Map(), offsets: new Map() });
+    if (!scopes.has(scope)) scopes.set(scope, { assigns: new Map(), offsets: new Map(), partialIfs: new Map() });
     return scopes.get(scope);
   };
   const push = (map, name, value) => map.set(name, [...(map.get(name) || []), value]);
   walkPhp(ast, (node, scope) => {
+    if (node.kind === 'if') {
+      const v = partialIfVar(node.test);
+      if (v) push(info(scope).partialIfs, v, node);
+    }
     if (node.kind === 'assign') {
       const left = node.left;
       if (left.kind === 'variable' && typeof left.name === 'string') push(info(scope).assigns, left.name, node);
@@ -62,7 +80,7 @@ function resolveData(arg, scope, call, scopes) {
   if (!arg) return { reason: 'la llamada no tiene argumentos' };
   if (arg.kind === 'array') return { arr: arg };
   if (arg.kind !== 'variable' || typeof arg.name !== 'string') return { reason: 'no es un array literal ni una variable' };
-  const s = scopes.get(scope) || { assigns: new Map(), offsets: new Map() };
+  const s = scopes.get(scope) || { assigns: new Map(), offsets: new Map(), partialIfs: new Map() };
   const defs = s.assigns.get(arg.name) || [];
   const v = `$${arg.name}`;
   if (defs.length === 0) {
@@ -81,9 +99,14 @@ function resolveData(arg, scope, call, scopes) {
   if (def.operator !== '=' || def.right.kind !== 'array') return { reason: `${v} no es un array literal` };
   if (def.loc.start.offset > call.loc.start.offset) return { reason: `${v} se define después de la llamada` };
   const offsets = s.offsets.get(arg.name) || [];
-  if (offsets.some((o) => o.key === FIELD)) return { migrated: true };
+  // $data['CondicionIVAReceptorId'] = ... : migrado, salvo que solo pase dentro del if del arreglo parcial.
+  const fieldSets = offsets.filter((o) => o.key === FIELD);
+  const ifs = s.partialIfs.get(arg.name) || [];
+  const insideIf = (o) => ifs.some((i) => o.node.loc.start.offset >= i.loc.start.offset && o.node.loc.end.offset <= i.loc.end.offset);
+  const partial = fieldSets.length > 0 && fieldSets.every(insideIf);
+  if (fieldSets.length && !partial) return { migrated: true };
   if (offsets.some((o) => o.key === undefined || DECISION_KEYS.has(o.key))) return { reason: `${v} se completa en varios pasos` };
-  return { arr: def.right };
+  return { arr: def.right, def, name: arg.name, partial };
 }
 
 export default function transform({ source, file, pack, context = emptyContext() }) {
@@ -120,9 +143,28 @@ export default function transform({ source, file, pack, context = emptyContext()
     if (byKey(FIELD) || edited.has(data.arr)) continue; // ya está migrado (o ya lo editamos)
 
     const d = decideCondition({ docTipo: phpLiteral(byKey('DocTipo')?.value), cbteTipo: phpLiteral(byKey('CbteTipo')?.value) }, pack);
+    const suggestion = `'${FIELD}' => <condición del cliente>,  // valores válidos: ${validCodesText(d, pack)}`;
+    if (data.partial) {
+      // Ya tiene el arreglo parcial: no se toca, pero lo que falta se sigue reportando.
+      const pending = partialPending(d, pack, suggestion);
+      findings.push(finding(PACK, file, call, 'needs-input', partialLeftMessage(pending), { suggestion }));
+      continue;
+    }
     if (d.status === 'needs-input') {
-      findings.push(finding(PACK, file, call, 'needs-input', missingMessage(d) + (caveat ? ` ${caveat}` : ''),
-        { suggestion: `'${FIELD}' => <condición del cliente>,  // valores válidos: ${validCodesText(d, pack)}` }));
+      // DocTipo no literal y $data en una variable: arreglo parcial con un if después de armar el array.
+      // Con un array dentro de la llamada no hay dónde poner el if, y `null` no sirve: mandarlo antes del 1/12
+      // podría generar un rechazo que hoy no existe (frente B, punto 7).
+      const docTipo = byKey('DocTipo');
+      const partialEdit = data.def && docTipo && phpLiteral(docTipo.value) === undefined
+        && canApplyAtRuntime(d, phpLiteral(byKey('CbteTipo')?.value)) ? insertPartialIf(source, data, entries) : null;
+      if (partialEdit) {
+        edits.push(partialEdit.edit);
+        edited.add(data.arr);
+        findings.push(finding(PACK, file, call, 'needs-review', partialAppliedMessage(partialEdit.read) + (caveat ? ` ${caveat}` : ''),
+          { partial: partialPending(d, pack, suggestion) }));
+        continue;
+      }
+      findings.push(finding(PACK, file, call, 'needs-input', missingMessage(d) + (caveat ? ` ${caveat}` : ''), { suggestion }));
       continue;
     }
     const anchor = byKey('DocNro') || entries[entries.length - 1];
@@ -139,13 +181,52 @@ export default function transform({ source, file, pack, context = emptyContext()
   return { output: edits.length ? applyEdits(source, edits) : null, findings, usages };
 }
 
+// Comillas de las claves del array: las que use la mayoría.
+function quoteOf(source, entries) {
+  const keyed = entries.filter((e) => e.key && e.key.kind === 'string');
+  const doubles = keyed.filter((e) => source[e.key.loc.start.offset] === '"').length;
+  return doubles > keyed.length / 2 ? '"' : "'";
+}
+
+// Arreglo parcial en PHP: después de `$data = [...];` agrega
+//   if ((int) $data['DocTipo'] === 99) { $data['CondicionIVAReceptorId'] = 5; }
+// en tres líneas, con la indentación del archivo. Lee DocTipo del array ya armado, así no repite la
+// expresión original (puede ser una llamada). (int) y === : '99' como string también cuenta, como en JS.
+// null si la asignación no termina la línea (dentro de un if, varias sentencias en una línea...).
+function insertPartialIf(source, data, entries) {
+  const eol = eolOf(source);
+  const { def, name } = data;
+  let semi = def.loc.end.offset - 1;
+  if (source[semi] !== ';') {
+    semi = def.loc.end.offset;
+    while (semi < source.length && /[ \t]/.test(source[semi])) semi++;
+    if (source[semi] !== ';') return null;
+  }
+  const nl = source.indexOf('\n', semi);
+  const rest = source.slice(semi + 1, nl === -1 ? source.length : nl);
+  if (nl === -1 || !(rest.trim() === '' || /^\s*(\/\/|#)/.test(rest))) return null;
+  const lineStart = source.lastIndexOf('\n', def.loc.start.offset - 1) + 1;
+  const indent = source.slice(lineStart).match(/^[ \t]*/)[0];
+  // Unidad de indentación: la de las claves del array respecto de la sentencia; si no, la del archivo.
+  const first = entries.find((e) => e.loc.start.line > def.loc.start.line);
+  const entryIndent = first ? source.slice(source.lastIndexOf('\n', first.loc.start.offset - 1) + 1).match(/^[ \t]*/)[0] : '';
+  const unit = entryIndent.startsWith(indent) && entryIndent.length > indent.length ? entryIndent.slice(indent.length)
+    : indent.includes('\t') ? '\t' : '    ';
+  const q = quoteOf(source, entries);
+  const read = `$${name}[${q}DocTipo${q}]`;
+  const text = `${indent}//${PARTIAL_COMMENT}${eol}`
+    + `${indent}if ((int) ${read} === 99) {${eol}`
+    + `${indent}${unit}$${name}[${q}${FIELD}${q}] = 5;${eol}`
+    + `${indent}}${eol}`;
+  return { edit: { offset: nl + 1, text }, read };
+}
+
 // Inserta 'CondicionIVAReceptorId' => N después de `anchor`, copiando el estilo del array:
 // comillas de las claves, indentación, alineación de los =>, coma final y fin de línea.
 export function insertAfterEntry(source, entries, anchor, { value, comment }) {
   const eol = eolOf(source);
   const keyed = entries.filter((e) => e.key && e.key.kind === 'string');
-  const doubles = keyed.filter((e) => source[e.key.loc.start.offset] === '"').length;
-  const q = doubles > keyed.length / 2 ? '"' : "'";
+  const q = quoteOf(source, entries);
   const key = `${q}${FIELD}${q}`;
 
   const end = anchor.loc.end.offset;

package/src/codemods/arca-wsfe-condicion-iva.js

@@ -2,10 +2,11 @@
 // Agrega CondicionIVAReceptorId a cada pedido de CAE hecho con afip.js cuando se puede inferir
 // sin datos del negocio, y marca el resto para que una persona complete el dato.
 import {
-  jFor, detectQuote, eolOf, offsetAt, applyEdits, getProp, hasSpread, isQuotedKey, isPlainProp, literalValue, resolveBinding, finding,
+  jFor, detectQuote, eolOf, offsetAt, applyEdits, getProp, isQuotedKey, isPlainProp, literalValue, resolveBinding, finding,
 } from '../ast.js';
 import {
   PACK, decideCondition, validCodesText, missingMessage, appliedMessage, soapDetection, ARCA_HINT, libraryCaveat, alreadyMigratedPrefix,
+  canApplyAtRuntime, PARTIAL_COMMENT, partialAppliedMessage, partialPending, partialLeftMessage,
 } from './arca-rules.js';
 import { emptyContext } from '../context.js';
 
@@ -45,6 +46,76 @@ export function decide(obj, pack) {
   }, pack);
 }
 
+// Un valor que se puede volver a leer sin efectos: docTipo, cliente.docTipo, this.doc?.tipo, datos['DocTipo'].
+// El arreglo parcial repite esa expresión; una llamada o un await no se repiten.
+function isPureRead(node, top = true) {
+  const n = unwrap(node);
+  if (!n) return false;
+  if (n.type === 'Identifier') return n.name !== 'undefined';
+  if (n.type === 'ThisExpression') return !top;
+  if (n.type === 'MemberExpression' || n.type === 'OptionalMemberExpression') {
+    if (n.computed && !['StringLiteral', 'NumericLiteral', 'Literal'].includes(n.property.type)) return false;
+    return isPureRead(n.object, false);
+  }
+  return false;
+}
+
+// ...(cond ? { CondicionIVAReceptorId: N } : {}): 'partial' si para el otro caso no hay valor (el arreglo
+// parcial de Parche, o uno igual escrito a mano), 'full' si los dos lados ponen el campo.
+function conditionSpread(prop) {
+  if (prop.type !== 'SpreadElement' && prop.type !== 'SpreadProperty') return null;
+  const c = unwrap(prop.argument);
+  if (!c || c.type !== 'ConditionalExpression') return null;
+  const sets = (o) => { const x = unwrap(o); return !!(x && x.type === 'ObjectExpression' && getProp(x, 'CondicionIVAReceptorId')); };
+  if (!sets(c.consequent) && !sets(c.alternate)) return null;
+  return sets(c.consequent) && sets(c.alternate) ? 'full' : 'partial';
+}
+const otherSpread = (obj) => obj.properties.some((p) => (p.type === 'SpreadElement' || p.type === 'SpreadProperty' || p.type === 'ObjectMethod') && !conditionSpread(p));
+
+const textOf = (source, node) => source.slice(offsetAt(source, node.loc.start), offsetAt(source, node.loc.end));
+
+// Nombre de la propiedad de un acceso: voucher.Campo o voucher['Campo'].
+const memberName = (m) => (!m.computed && m.property.type === 'Identifier' ? m.property.name
+  : m.computed && (m.property.type === 'StringLiteral' || m.property.type === 'Literal') ? m.property.value : null);
+
+// ¿El objeto de la variable `name` (declarada en `decl`) recibe el campo después de armarse?
+// voucher.CondicionIVAReceptorId = …, voucher['CondicionIVAReceptorId'] = …, (voucher as any).CondicionIVAReceptorId = …
+// u Object.assign(voucher, { CondicionIVAReceptorId: … }). Cuenta como migrado, igual que en PHP
+// (frente B, punto 18: tometh04/vibook-services lo asigna en un if y Parche agregaba el arreglo parcial igual).
+// Solo cuenta si es la misma variable: otra con el mismo nombre en otra función no.
+function fieldAssignedLater(j, root, decl, name) {
+  const same = (p) => resolveBinding(p, name)?.node === decl.node;
+  const isVar = (n) => { const x = unwrap(n); return !!(x && x.type === 'Identifier' && x.name === name); };
+  const assigned = root.find(j.AssignmentExpression).filter((p) => {
+    const left = unwrap(p.node.left);
+    return left && left.type === 'MemberExpression' && isVar(left.object) && memberName(left) === 'CondicionIVAReceptorId' && same(p);
+  }).size() > 0;
+  if (assigned) return true;
+  return root.find(j.CallExpression).filter((p) => {
+    const c = unwrap(p.node.callee);
+    const isAssign = c && c.type === 'MemberExpression' && !c.computed && c.object.type === 'Identifier' && c.object.name === 'Object'
+      && c.property.type === 'Identifier' && c.property.name === 'assign';
+    if (!isAssign || !isVar(p.node.arguments[0]) || !same(p)) return false;
+    return p.node.arguments.slice(1).some((a) => { const o = unwrap(a); return o && o.type === 'ObjectExpression' && !!getProp(o, 'CondicionIVAReceptorId'); });
+  }).size() > 0;
+}
+
+// La clave nueva copia el estilo del objeto: con comillas si la mayoría de las claves las tiene, y las
+// mismas comillas que esas claves. Las del resto del archivo solo desempatan: en un repo real las claves
+// iban con ' y el archivo usaba " en el resto, y la clave nueva salía distinta a sus vecinas.
+function keyTextFor(source, obj) {
+  const props = obj.properties.filter(isPlainProp);
+  const quotedKeys = props.filter(isQuotedKey);
+  if (!props.length || quotedKeys.length < props.length / 2) return 'CondicionIVAReceptorId';
+  const raw = (k) => (k.extra?.raw ?? k.raw ?? source[offsetAt(source, k.loc.start)])[0];
+  const doubles = quotedKeys.filter((p) => raw(p.key) === '"').length;
+  const singles = quotedKeys.length - doubles;
+  const q = doubles === singles ? (detectQuote(source) === 'double' ? '"' : "'") : doubles > singles ? '"' : "'";
+  return `${q}CondicionIVAReceptorId${q}`;
+}
+
+const suggestionFor = (d, pack) => `'CondicionIVAReceptorId': <condición del cliente>,  // valores válidos: ${validCodesText(d, pack)}`;
+
 export default function transform({ source, file, pack, context = emptyContext() }) {
   const findings = [];
   const usages = [];
@@ -72,31 +143,51 @@ export default function transform({ source, file, pack, context = emptyContext()
     usages.push({ provider: 'arca', op: `ElectronicBilling.${voucherCallee(p).property.name}`, line: call.loc?.start.line });
     const arg = call.arguments[0];
     let obj = null;
+    let binding = null;
     if (arg && arg.type === 'ObjectExpression') obj = arg;
     else if (arg && arg.type === 'Identifier') {
       const decl = resolveBinding(p, arg.name);
-      if (decl && decl.node.init && decl.node.init.type === 'ObjectExpression') obj = decl.node.init;
+      if (decl && decl.node.init && decl.node.init.type === 'ObjectExpression') { obj = decl.node.init; binding = decl; }
     }
-    if (!obj || hasSpread(obj)) {
+    if (!obj || otherSpread(obj)) {
       // Si el repo ya usa el campo en otro lado, lo más probable es que el builder ya lo ponga: "revisar".
       findings.push(finding(PACK, file, call, migrated ? 'needs-review' : 'needs-input', (migrated || '') + unreadableMessage(j, root, p, arg, obj)));
       return;
     }
     if (getProp(obj, 'CondicionIVAReceptorId') || edited.has(obj)) return; // ya está migrado (o ya lo editamos)
+    if (binding && fieldAssignedLater(j, root, binding, arg.name)) return; // lo completa después: también migrado
+    const spreads = obj.properties.map(conditionSpread);
+    if (spreads.includes('full')) return;
 
     const d = decide(obj, pack);
+    const props = obj.properties.filter(isPlainProp);
+    const keyText = keyTextFor(source, obj);
+    const anchor = getProp(obj, 'DocNro') || props[props.length - 1];
+    const isLast = anchor === obj.properties[obj.properties.length - 1];
+    if (spreads.includes('partial')) {
+      // Ya tiene el arreglo parcial: no se toca, pero lo que falta se sigue reportando.
+      const pending = partialPending(d, pack, suggestionFor(d, pack));
+      findings.push(finding(PACK, file, call, 'needs-input', partialLeftMessage(pending), { suggestion: pending.suggestion }));
+      return;
+    }
     if (d.status === 'needs-input') {
+      const docTipo = getProp(obj, 'DocTipo')?.value;
+      const expr = docTipo && anchor && literalValue(docTipo) === undefined && isPureRead(docTipo) ? textOf(source, docTipo) : null;
+      if (expr && !expr.includes('\n') && canApplyAtRuntime(d, literalValue(getProp(obj, 'CbteTipo')?.value))) {
+        // Spread y no `CondicionIVAReceptorId: x === 99 ? 5 : undefined`: con otro DocTipo la clave ni existe,
+        // así el pedido queda idéntico al de hoy sin depender de cómo serialice la librería (decisión D52).
+        edits.push(...insertAfterProp(source, anchor, `...(Number(${expr}) === 99 ? { ${keyText}: 5 } : {})`, PARTIAL_COMMENT, { isLast }));
+        edited.add(obj);
+        changed = true;
+        findings.push(finding(PACK, file, call, 'needs-review', partialAppliedMessage(expr) + (caveat ? ` ${caveat}` : ''),
+          { partial: partialPending(d, pack, suggestionFor(d, pack)) }));
+        return;
+      }
       findings.push(finding(PACK, file, call, 'needs-input', missingMessage(d) + (caveat ? ` ${caveat}` : ''),
-        { suggestion: `'CondicionIVAReceptorId': <condición del cliente>,  // valores válidos: ${validCodesText(d, pack)}` }));
+        { suggestion: suggestionFor(d, pack) }));
       return;
     }
 
-    const props = obj.properties.filter(isPlainProp);
-    const quoted = props.length > 0 && props.filter(isQuotedKey).length >= props.length / 2;
-    const q = detectQuote(source) === 'double' ? '"' : "'";
-    const keyText = quoted ? `${q}CondicionIVAReceptorId${q}` : 'CondicionIVAReceptorId';
-    const anchor = getProp(obj, 'DocNro') || props[props.length - 1];
-    const isLast = anchor === obj.properties[obj.properties.length - 1];
     edits.push(...insertAfterProp(source, anchor, `${keyText}: ${d.code}`, d.comment, { isLast }));
     edited.add(obj);
     changed = true;

package/src/engine.js

@@ -2,7 +2,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { loadPacks, transformFor, languageOf } from './packs.js';
-import { SKIP_DIRS, toPosix } from './paths.js';
+import { SKIP_DIRS, toPosix, isBackupDir, isBackupFile } from './paths.js';
 import { scanJs } from './inventory/js-scan.js';
 import { readManifests, buildInventory } from './inventory/index.js';
 import { buildContext } from './context.js';
@@ -10,18 +10,25 @@ import { buildContext } from './context.js';
 // JS/TS y PHP (codemods), WSDL (detección de esquemas viejos) y Python, C#, Java, Go, VB.NET (solo detección).
 const EXT = /\.(m?js|cjs|jsx|ts|tsx|php|wsdl|py|cs|java|go|vb)$/i;
 
-export function listFiles(dir) {
+// Archivos que el motor lee. Las copias de respaldo (BAK/, "x copy.php"…) no se leen ni se editan:
+// van a `skipped`, con "/", para decir en el reporte qué se ignoró.
+export function listFiles(dir, skipped = []) {
   const out = [];
   const walk = (d) => {
     for (const e of fs.readdirSync(d, { withFileTypes: true })) {
+      const rel = () => toPosix(path.relative(dir, path.join(d, e.name)));
       if (e.isDirectory()) {
-        if (!SKIP_DIRS.has(e.name)) walk(path.join(d, e.name));
+        if (SKIP_DIRS.has(e.name)) continue;
+        if (isBackupDir(e.name)) { skipped.push(`${rel()}/`); continue; }
+        walk(path.join(d, e.name));
       } else if (EXT.test(e.name) && !/\.d\.ts$/.test(e.name)) {
-        out.push(path.join(d, e.name));
+        if (isBackupFile(e.name)) skipped.push(rel());
+        else out.push(path.join(d, e.name));
       }
     }
   };
   walk(dir);
+  skipped.sort();
   // Mismo orden en Windows y en Linux: se ordena por la ruta con "/".
   return out.sort((a, b) => (toPosix(a) < toPosix(b) ? -1 : 1));
 }
@@ -31,7 +38,8 @@ export function run(dir, { write = false, packIds = null, today } = {}) {
   const packs = loadPacks().filter((p) => !packIds || packIds.includes(p.id));
   const manifests = readManifests(root);
   const deps = { ...manifests.npm, ...manifests.composer };
-  const files = listFiles(root);
+  const skipped = [];
+  const files = listFiles(root, skipped);
   const rels = files.map((abs) => toPosix(path.relative(root, abs)));
   // Lo que un archivo solo no sabe (versiones instaladas, si el repo ya usa el campo, WSDL viejos).
   const context = buildContext(root, rels, manifests);
@@ -83,7 +91,7 @@ export function run(dir, { write = false, packIds = null, today } = {}) {
     providers: Object.fromEntries(Object.entries(providers).map(([k, v]) => [k, { ...v, files: [...v.files] }])),
     usages,
   };
-  return { root, packs, context, inventory, findings, changed: [...changed.entries()].map(([file, packIds]) => ({ file, packs: packIds })) };
+  return { root, packs, context, inventory, findings, skipped, changed: [...changed.entries()].map(([file, packIds]) => ({ file, packs: packIds })) };
 }
 
 export const STATUS_ORDER = ['blocked', 'needs-input', 'needs-review', 'auto', 'detect-only'];

package/src/git.js

@@ -1,6 +1,9 @@
 import { execFileSync } from 'node:child_process';
 
-const git = (cwd, ...args) => execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+// En Windows, sin core.longpaths, git ve modificado un archivo con ruta de más de 260 caracteres, y `parche pr`
+// frenaba con "Hay cambios sin commitear" en un clon recién hecho (frente B, punto 20).
+export const gitArgs = (args, platform = process.platform) => (platform === 'win32' ? ['-c', 'core.longpaths=true', ...args] : args);
+const git = (cwd, ...args) => execFileSync('git', gitArgs(args), { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
 
 export function isRepo(cwd) {
   try {
@@ -48,6 +51,17 @@ export function commitIdentity(cwd, env = process.env) {
   throw new Error('No hay una identidad de git para firmar el commit: configurá `git config user.name` y `git config user.email`, o PARCHE_GIT_NAME y PARCHE_GIT_EMAIL.');
 }
 
+// --author "Nombre <email>": quién firma, sin tocar la configuración de git de la máquina (frente B, punto 20:
+// la identidad global de la compu era otra persona con un mail personal).
+export function parseAuthor(text) {
+  const m = /^\s*(.+?)\s*<([^<>\s]+@[^<>\s]+)>\s*$/.exec(typeof text === 'string' ? text : '');
+  if (!m) throw new Error('--author tiene que ser "Nombre <email>", por ejemplo --author "Ana Pérez <ana@users.noreply.github.com>".');
+  return { PARCHE_GIT_NAME: m[1], PARCHE_GIT_EMAIL: m[2] };
+}
+
+// El email del commit queda público en el PR: si no es un noreply de GitHub, `parche pr` avisa antes de pushear.
+export const isNoreply = (email) => /@users\.noreply\.github\.com$/i.test(email || '');
+
 export function commitAll(cwd, message, env = process.env) {
   const id = commitIdentity(cwd, env);
   git(cwd, 'add', '-A');

package/src/paths.js

@@ -16,9 +16,19 @@ export function isTestFile(file) {
     || /\.(test|spec|mock)\.[cm]?[jt]sx?$/i.test(file) || /Test\.php$/.test(file);
 }
 
-// Recorre el repo (salteando SKIP_DIRS) y devuelve las rutas relativas, con "/", de los archivos que
-// cumplen `match(nombre)`.
-export function findFiles(root, match) {
+// Copias de respaldo: no es el código que corre. Un PR sobre BAK/ o sobre "factura copy.php" no le sirve al
+// mantenedor (frente B, 17/10: axel-tecnosoul/facturador ya usaba el campo en los archivos vigentes).
+// Carpetas BAK, backup(s), old, _old y deprecated; archivos "x copy.php", "x - Copy.js", "x copia.php",
+// "x.bak.php", "x-old.js", "x_old.php" y "x.old.php". No cuentan "deep_copy.js" ni "gold.js".
+const BACKUP_DIR = /^(bak|backups?|old|_old|deprecated)$/i;
+export const isBackupDir = (name) => BACKUP_DIR.test(name);
+export function isBackupFile(name) {
+  return /\s(-\s)?(copy|copia)(\s\(?\d+\)?)?\.[^.]+$/i.test(name) || /\.bak\.[^.]+$/i.test(name) || /[-_.]old\.[^.]+$/i.test(name);
+}
+
+// Recorre el repo (salteando SKIP_DIRS y las copias de respaldo) y devuelve las rutas relativas, con "/",
+// de los archivos que cumplen `match(nombre)`. Lo salteado por ser respaldo va a `skipped`, si se pasa.
+export function findFiles(root, match, skipped = null) {
   const out = [];
   const walk = (dir) => {
     let entries;
@@ -28,8 +38,15 @@ export function findFiles(root, match) {
       return;
     }
     for (const e of entries) {
-      if (e.isDirectory()) { if (!SKIP_DIRS.has(e.name)) walk(path.join(dir, e.name)); }
-      else if (match(e.name)) out.push(toPosix(path.relative(root, path.join(dir, e.name))));
+      const rel = () => toPosix(path.relative(root, path.join(dir, e.name)));
+      if (e.isDirectory()) {
+        if (SKIP_DIRS.has(e.name)) continue;
+        if (isBackupDir(e.name)) { skipped?.push(`${rel()}/`); continue; }
+        walk(path.join(dir, e.name));
+      } else if (match(e.name)) {
+        if (isBackupFile(e.name)) skipped?.push(rel());
+        else out.push(rel());
+      }
     }
   };
   walk(root);

package/src/report.js

@@ -53,7 +53,7 @@ function upgradesSection(upgrades) {
   return out;
 }
 
-export function scanReport({ inventory, findings, packs, changed, upgrades = null }, today = new Date()) {
+export function scanReport({ inventory, findings, packs, changed, upgrades = null, skipped = [] }, today = new Date()) {
   const out = [];
   out.push(`# Parche — reporte de \`${inventory.repo}\``, '');
   out.push('## APIs que usa este repo', '');
@@ -73,6 +73,10 @@ export function scanReport({ inventory, findings, packs, changed, upgrades = nul
     out.push('**Llamadas HTTP con URL dinámica** (no se puede saber a qué host van):', '',
       ...inventory.unresolved.map((u) => `- \`${u.file}:${u.line}\` (${u.client})`), '');
   }
+  if (skipped.length) {
+    out.push('**Copias de respaldo que no se revisaron** (si alguna es código que corre, renombrala o movela):', '',
+      ...skipped.map((s) => `- \`${s}\``), '');
+  }
   if (upgrades) out.push(...upgradesSection(upgrades));
   for (const pack of packs) {
     const fs = findings.filter((f) => f.pack === pack.id);
@@ -83,6 +87,7 @@ export function scanReport({ inventory, findings, packs, changed, upgrades = nul
     for (const f of fs) {
       out.push(`- ${LABEL[f.status]} \`${f.file}${f.line ? `:${f.line}` : ''}\` — ${f.message}`);
       if (f.suggestion) out.push(`  - Sugerido: \`${f.suggestion}\``);
+      if (f.partial) out.push(`  - ${LABEL['needs-input']} ${f.partial.message}`, `  - Cuando tengas el dato: \`${f.partial.suggestion}\``);
     }
     out.push('');
   }
@@ -92,6 +97,11 @@ export function scanReport({ inventory, findings, packs, changed, upgrades = nul
   return out.join('\n');
 }
 
+// Si algún arreglo es parcial, qué casos cubre ("consumidor final"): va en el título y arriba del cuerpo del PR.
+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()) {
   const fs = findings.filter((f) => f.pack === pack.id);
   const c = counts(fs);
@@ -102,12 +112,20 @@ export function prBody({ pack, findings, changed, verification }, today = new Da
   // Sin cambios de código el texto se usa como issue: los títulos no pueden hablar de "este PR".
   const asIssue = !changed.length;
   out.push(asIssue ? '### Qué encontró Parche' : '### Qué hace este PR', '');
+  const covers = partialCovers(fs);
+  if (covers.length && !asIssue) {
+    out.push(`> **Este PR es parcial (${covers.join(', ')}).** Arregla solo esos casos, sin inventar datos: el resto del pedido sale igual que hoy. Lo que no cubre está en "Lo que este PR NO resuelve" y hay que completarlo antes de la fecha límite.`, '');
+  }
   const applied = fs.filter((f) => f.status === 'auto' || f.status === 'needs-review');
   out.push(changed.length
     ? `Modifica ${changed.length} archivo(s): ${changed.map((x) => `\`${x.file}\``).join(', ')}.`
     : 'No hay un arreglo automático seguro: esto es lo que hay que resolver a mano.', '');
   for (const f of applied) out.push(`- ${LABEL[f.status]} \`${f.file}:${f.line}\` — ${f.message}`);
-  const pending = fs.filter((f) => f.status === 'needs-input' || f.status === 'blocked');
+  // Lo que falta: los hallazgos sin arreglo y, de cada arreglo parcial, la parte que no cubre.
+  const pending = [
+    ...fs.filter((f) => f.status === 'needs-input' || f.status === 'blocked'),
+    ...fs.filter((f) => f.partial).map((f) => ({ ...f, status: 'needs-input', message: f.partial.message, suggestion: f.partial.suggestion })),
+  ];
   if (pending.length) {
     out.push('', asIssue ? '### Lo que hay que resolver (necesita una persona)' : '### Lo que este PR NO resuelve (necesita una persona)', '');
     for (const f of pending) {