@jpkme/diff-review 0.1.14 → 0.1.16

package/bin/diff-review.mjs

@@ -233,8 +233,9 @@ function ensureValue(value, label) {
  * Selects interactivos salvo que --branch y --base vengan juntos.
  * @param {{ listed: { branches: string[], current: string, defaultBase: string }, repo: string }} launch
  * @param {{ branch: string, base: string }} opts
+ * @param {{ skipIntro?: boolean }} [pickOpts]
  */
-async function resolveBranchBase(launch, opts) {
+async function resolveBranchBase(launch, opts, pickOpts = {}) {
 	const flagBranch = String(opts.branch || '').trim();
 	const flagBase = String(opts.base || '').trim();
 	const bothFlags = Boolean(flagBranch && flagBase);
@@ -255,61 +256,86 @@ async function resolveBranchBase(launch, opts) {
 	}
 
 	const options = branchOptions(launch.listed);
-	p.intro('diff-review');
-	p.log.info(launch.repo);
+	if (!pickOpts.skipIntro) {
+		p.intro('diff-review');
+		p.log.info(launch.repo);
+	}
 
+	/** @type {string} */
 	let branch = flagBranch;
-	if (!branch) {
-		branch = ensureValue(
-			await autocompleteEs({
-				message: 'Branch a revisar',
-				options,
-				initialValue: defaultBranch(launch.listed) || undefined,
-				maxItems: 12
-			}),
-			'branch'
-		);
-	} else {
-		p.log.step(`Branch: ${branch}`);
-	}
+	/** @type {string} */
+	let base = flagBase;
+	let first = true;
 
-	const baseOptions = branchOptions(launch.listed, branch);
-	if (!baseOptions.length) {
-		p.cancel(`No hay otra base disponible distinta de \`${branch}\`.`);
-		process.exit(1);
-	}
+	for (;;) {
+		if (!first) {
+			// Diff vacío / tips iguales: volver a preguntar branch y base (no solo la base).
+			branch = '';
+			base = '';
+		}
+		first = false;
+
+		if (!branch) {
+			branch = ensureValue(
+				await autocompleteEs({
+					message: 'Branch a revisar',
+					options,
+					initialValue: defaultBranch(launch.listed) || undefined,
+					maxItems: 12
+				}),
+				'branch'
+			);
+		} else {
+			p.log.step(`Branch: ${branch}`);
+		}
 
-	let base = flagBase;
-	if (!base) {
-		base = ensureValue(
-			await autocompleteEs({
-				message: 'Base (merge-base)',
-				options: baseOptions,
-				initialValue: defaultBase(launch.listed, branch) || undefined,
-				maxItems: 12
-			}),
-			'base'
-		);
-	} else {
-		p.log.step(`Base: ${base}`);
-	}
+		const baseOptions = branchOptions(launch.listed, branch);
+		if (!baseOptions.length) {
+			p.cancel(`No hay otra base disponible distinta de \`${branch}\`.`);
+			process.exit(1);
+		}
 
-	while (branch === base) {
-		p.log.warn(`Branch y base son iguales (${branch}): el diff estaría vacío.`);
-		base = ensureValue(
-			await autocompleteEs({
-				message: 'Elegí otra base',
-				options: baseOptions,
-				initialValue: defaultBase(launch.listed, branch) || undefined,
-				maxItems: 12
-			}),
-			'base'
-		);
+		if (!base) {
+			base = ensureValue(
+				await autocompleteEs({
+					message: 'Base (merge-base)',
+					options: baseOptions,
+					initialValue: defaultBase(launch.listed, branch) || undefined,
+					maxItems: 12
+				}),
+				'base'
+			);
+		} else {
+			p.log.step(`Base: ${base}`);
+		}
+
+		if (branch === base || sameCommitTips(launch.repo, branch, base)) {
+			p.log.warn(emptyDiffPickMessage(branch, base));
+			continue;
+		}
+		break;
 	}
 
 	return { branch, base, prompted: true };
 }
 
+/** ¿Branch y base resuelven al mismo SHA? (diff committed vacío aunque los nombres difieran). */
+function sameCommitTips(repo, branch, base) {
+	try {
+		const { branchSha, baseSha } = branchTips(repo, branch, base);
+		return Boolean(branchSha && baseSha && branchSha === baseSha);
+	} catch {
+		return false;
+	}
+}
+
+function emptyDiffPickMessage(branch, base) {
+	if (branch === base) {
+		return `Branch y base son iguales (${branch}): no hay diff que revisar.`;
+	}
+	return `\`${branch}\` y \`${base}\` apuntan al mismo commit: no hay diff que revisar.`;
+}
+
 function buildOutputFilename(repo, branch, base) {
 	try {
 		const tips = branchTips(repo, branch, base);
@@ -327,10 +353,10 @@ function buildOutputFilename(repo, branch, base) {
 }
 
 /**
- * Precomputa el diff en CLI (spinner si hay Clack). Si el resultado no tiene archivos, sale con error.
- * @returns {ReturnType<typeof prepareReviewPromptOpts>}
+ * Precomputa el diff en CLI (spinner si hay Clack).
+ * @returns {{ empty: true, message: string } | { empty: false, promptOpts: ReturnType<typeof prepareReviewPromptOpts> }}
  */
-function prepareContextOrFail(launch, branch, base, outputFilename, { useClack }) {
+function prepareContext(launch, branch, base, outputFilename, { useClack }) {
 	const spin = useClack ? p.spinner() : null;
 	if (!useClack) console.log('Preparando el contexto…');
 	spin?.start('Preparando el contexto…');
@@ -351,22 +377,22 @@ function prepareContextOrFail(launch, branch, base, outputFilename, { useClack }
 		else console.warn('No pude precomputar el diff:', msg);
 		ensureReviewDir(launch.repo);
 		writeDiffCache(launch.repo, outputFilename, { branch, base });
-		return promptOpts;
+		return { empty: false, promptOpts };
 	}
 
 	const n = Array.isArray(promptOpts.files) ? promptOpts.files.length : 0;
 	if (n === 0) {
 		spin?.stop('Diff vacío');
-		const msg = `El diff entre \`${branch}\` y \`${base}\` está vacío: no hay nada que revisar.`;
-		if (useClack) p.cancel(msg);
-		else console.error(msg);
-		process.exit(1);
+		return {
+			empty: true,
+			message: `El diff entre \`${branch}\` y \`${base}\` está vacío: no hay nada que revisar.`
+		};
 	}
 
 	const done = `Contexto listo · ${n} archivo${n === 1 ? '' : 's'}`;
 	spin?.stop(done);
 	if (!useClack) console.log(done);
-	return promptOpts;
+	return { empty: false, promptOpts };
 }
 
 function copyPromptOrWarn(prompt) {
@@ -674,9 +700,15 @@ async function runUiMode(opts, launch, launchCwd) {
 	if (launch) {
 		console.log(`Repo:   ${launch.repo}`);
 		console.log(`Branch: ${branch}  (base: ${base})`);
-		const promptOpts = prepareContextOrFail(launch, branch, base, outputFilename, {
-			useClack: false
-		});
+		if (branch === base || sameCommitTips(launch.repo, branch, base)) {
+			console.error(emptyDiffPickMessage(branch, base));
+			process.exit(1);
+		}
+		const prep = prepareContext(launch, branch, base, outputFilename, { useClack: false });
+		if (prep.empty) {
+			console.error(prep.message);
+			process.exit(1);
+		}
 		const prompt = buildPrompt(
 			{
 				source: 'local',
@@ -685,7 +717,7 @@ async function runUiMode(opts, launch, launchCwd) {
 				base,
 				remoteUrl: launch.remoteUrl
 			},
-			promptOpts
+			prep.promptOpts
 		);
 		if (copyTextToClipboard(prompt)) {
 			console.log('Prompt copiado al portapapeles.');
@@ -734,27 +766,59 @@ async function main() {
 		process.exit(1);
 	}
 
-	const { branch, base, prompted } = await resolveBranchBase(launch, opts);
+	/** @type {{ branch: string, base: string }} */
+	let pick = { branch: opts.branch, base: opts.base };
+	let skipIntro = false;
+	/** @type {string} */
+	let branch;
+	/** @type {string} */
+	let base;
+	/** @type {boolean} */
+	let prompted;
+	/** @type {string} */
+	let outputFilename;
+	/** @type {ReturnType<typeof prepareReviewPromptOpts>} */
+	let promptOpts;
 
-	if (branch === base) {
-		const msg = `Branch y base son iguales (${branch}): no hay diff que revisar.`;
-		if (prompted) p.cancel(msg);
-		else console.error(msg);
-		process.exit(1);
-	}
+	for (;;) {
+		({ branch, base, prompted } = await resolveBranchBase(launch, pick, { skipIntro }));
+		if (prompted) skipIntro = true;
 
-	const outputFilename = buildOutputFilename(launch.repo, branch, base);
-	if (!prompted) {
-		console.log(`Repo:   ${launch.repo}`);
-		console.log(`Branch: ${branch}  (base: ${base})`);
-	} else {
-		p.note(`${branch}  →  ${base}\n${outputRelPath(outputFilename)}`, 'Review');
-	}
+		if (branch === base || sameCommitTips(launch.repo, branch, base)) {
+			const msg = emptyDiffPickMessage(branch, base);
+			if (prompted || isInteractive()) {
+				p.log.warn(msg);
+				pick = { branch: '', base: '' };
+				continue;
+			}
+			console.error(msg);
+			process.exit(1);
+		}
 
-	// El agente escribe en .diff-review/ (que se ignora sola) y lee de ahí el diff ya calculado.
-	const promptOpts = prepareContextOrFail(launch, branch, base, outputFilename, {
-		useClack: prompted || isInteractive()
-	});
+		outputFilename = buildOutputFilename(launch.repo, branch, base);
+		if (!prompted) {
+			console.log(`Repo:   ${launch.repo}`);
+			console.log(`Branch: ${branch}  (base: ${base})`);
+		} else {
+			p.note(`${branch}  →  ${base}\n${outputRelPath(outputFilename)}`, 'Review');
+		}
+
+		// El agente escribe en .diff-review/ (que se ignora sola) y lee de ahí el diff ya calculado.
+		const prep = prepareContext(launch, branch, base, outputFilename, {
+			useClack: prompted || isInteractive()
+		});
+		if (prep.empty) {
+			if (prompted || isInteractive()) {
+				p.log.warn(prep.message);
+				pick = { branch: '', base: '' };
+				continue;
+			}
+			console.error(prep.message);
+			process.exit(1);
+		}
+		promptOpts = prep.promptOpts;
+		break;
+	}
 
 	const prompt = buildPrompt(
 		{

package/lib/acp-policy.mjs

@@ -13,8 +13,9 @@ import { checkShell } from "./acp-shell.mjs";
 import { outputRelPath } from "./output-name.mjs";
 
 /**
- * @typedef {"review" | "ask" | "edit"} PolicyMode
- *   review = generar el JSON; ask = preguntas (no puede escribir nada); edit = modificar el JSON.
+ * @typedef {"review" | "ask" | "edit" | "fix"} PolicyMode
+ *   review = generar el JSON; ask = preguntas (no puede escribir nada); edit = modificar el JSON;
+ *   fix = editar código dentro del repo (no solo el JSON).
  * @typedef {{ repo: string, outputFilename: string, mode: PolicyMode }} PolicyContext
  * @typedef {{
  *   kind?: string | null,
@@ -190,6 +191,13 @@ export function decidePermission(toolCall, { repo, outputFilename, mode }) {
   if (kind === "edit" || kind === "delete") {
     if (mode === "ask") return { allow: false, reason: "modo pregunta: no se edita nada" };
     if (!paths.length) return { allow: false, reason: `${kind === "delete" ? "borrado" : "edición"} sin path` };
+    // fix mode: puede editar cualquier archivo dentro del repo (no solo el JSON de salida como edit mode).
+    if (mode === "fix") {
+      const outside = paths.find((p) => !isInside(p, repo));
+      return outside
+        ? { allow: false, reason: `path fuera del repo: ${outside}` }
+        : { allow: true, reason: "escritura en el repo" };
+    }
     const target = resolve(repo, outputRelPath(outputFilename));
     const outside = paths.find((p) => !samePath(canonicalPath(p), canonicalPath(target)));
     return outside

package/lib/acp-policy.test.mjs

@@ -87,6 +87,33 @@ test("decidePermission: escritura solo del JSON objetivo, nunca en modo pregunta
   );
 });
 
+test("decidePermission: modo fix permite edit/delete dentro del repo, deniega fuera", () => {
+  assert.equal(decidePermission(edit(join(repo, "lib", "a.mjs")), ctx("fix")).allow, true);
+  assert.equal(decidePermission(edit("lib/a.mjs"), ctx("fix")).allow, true);
+  assert.equal(decidePermission(edit(outPath), ctx("fix")).allow, true);
+  const home = process.platform === "win32" ? "C:\\Users\\me\\.ssh\\id_rsa" : "/home/me/.ssh/id_rsa";
+  assert.equal(decidePermission(edit(home), ctx("fix")).allow, false);
+  assert.equal(decidePermission(edit(join(repo, "..", "otro", "x")), ctx("fix")).allow, false);
+  assert.equal(decidePermission({ kind: "edit", title: "Edit", rawInput: {} }, ctx("fix")).allow, false);
+  assert.equal(
+    decidePermission(
+      { kind: "delete", title: "Delete", rawInput: { path: join(repo, "lib", "a.mjs") }, locations: [{ path: join(repo, "lib", "a.mjs") }] },
+      ctx("fix")
+    ).allow,
+    true
+  );
+  assert.equal(
+    decidePermission(
+      { kind: "delete", title: "Delete", rawInput: { path: home }, locations: [{ path: home }] },
+      ctx("fix")
+    ).allow,
+    false
+  );
+  // ask/edit JSON sin regresiones frente a paths de código.
+  assert.equal(decidePermission(edit(join(repo, "lib", "a.mjs")), ctx("ask")).allow, false);
+  assert.equal(decidePermission(edit(join(repo, "lib", "a.mjs")), ctx("edit")).allow, false);
+});
+
 test("decidePermission: comandos según isAllowedShell y el resto rechazado", () => {
   assert.equal(decidePermission(bash("git diff a...b"), ctx("ask")).allow, true);
   assert.equal(decidePermission(bash("rm -rf ."), ctx()).allow, false);

package/lib/acp-shell.mjs

@@ -5,6 +5,9 @@
  *
  * El comando se tokeniza respetando comillas (un `grep "a\|b"` no es un pipe). Se aceptan `|`, `&&`, `||`, `;` y
  * descartar salida a /dev/null; cualquier otra redirección, `$(…)`, backticks o `&` lo rechazan.
+ *
+ * En PowerShell, `(Get-Content f).Count` llega como `(Get-Content` + `f).Count`: se quitan paréntesis de
+ * agrupación y el `.Miembro` colgado al path/flag antes de evaluar la allowlist.
  */
 import { realpathSync } from "node:fs";
 import { basename, dirname, isAbsolute, normalize, resolve } from "node:path";
@@ -376,6 +379,23 @@ function checkReviewDirMkdir(argv, ctx) {
   return null;
 }
 
+/**
+ * Quita agrupación PowerShell pegada al token: `(Get-Content` → `Get-Content`,
+ * `file.diff).Count` → `file.diff`, `-Line).Lines` → `-Line`.
+ * @param {string} token
+ */
+function stripPsGrouping(token) {
+  let t = String(token ?? "");
+  t = t.replace(/^\(+/, "");
+  t = t.replace(/\)+(?:\.[A-Za-z_][\w]*(?:\(\)?)?)*$/, "");
+  return t;
+}
+
+/** @param {string[]} argv */
+function normalizePsArgv(argv) {
+  return argv.map(stripPsGrouping).filter((w) => w.length > 0);
+}
+
 /**
  * @param {string} command
  * @param {{ repo?: string, platform?: NodeJS.Platform }} [opts]
@@ -387,7 +407,9 @@ export function checkShell(command, { repo, platform = process.platform } = {})
   if (!parsed.pipelines.length) return { ok: false, reason: "comando vacío" };
   const ctx = { repo: repo || process.cwd(), platform };
   for (const pipeline of parsed.pipelines) {
-    for (const argv of pipeline) {
+    for (const rawArgv of pipeline) {
+      const argv = normalizePsArgv(rawArgv);
+      if (!argv.length) continue;
       const name = argv[0].toLowerCase();
       if (argv[0].includes("=")) return { ok: false, reason: `variables de entorno en el comando: ${argv[0]}` };
       /** @type {ShellCheck} */

package/lib/acp-shell.test.mjs

@@ -64,6 +64,10 @@ test("checkShell deja git de lectura, el validate y comandos que solo leen", ()
     "git diff a...b -- lib 2>/dev/null || true",
     "Get-Content lib/agents.mjs | Select-Object -First 40",
     "Select-String -Path lib/*.mjs -Pattern 'export'",
+    // Agrupación PowerShell: `(cmd).Property` (Copilot/Opus suele contar líneas así).
+    "(Get-Content lib/agents.mjs).Count",
+    "(Get-Content .diff-review/diff-rev_x.diff).Count",
+    "(Get-Content lib/a.mjs | Measure-Object -Line).Lines",
   ]) {
     assert.equal(ok(cmd), true, cmd);
   }
@@ -73,6 +77,9 @@ test("checkShell rechaza escrituras, ejecución y paths fuera del repo", () => {
   const home = win ? "C:\\Users\\me\\.ssh\\id_rsa" : "/home/me/.ssh/id_rsa";
   for (const cmd of [
     "",
+    // Agrupar no habilita comandos fuera de la allowlist.
+    "(Remove-Item lib/a.mjs)",
+    "(Invoke-WebRequest https://example.com).Content",
     "git checkout main",
     "git branch -D feat",
     "git push",

package/lib/output-name.mjs

@@ -19,6 +19,13 @@ export function outputRelPath(filename) {
   return `${OUTPUT_DIR}/${String(filename || "").replace(/^.*[\\/]/, "")}`;
 }
 
+/** Companion de handoff: mismo stem que el JSON → `.diff-review/<stem>.chat.md`. */
+export function chatRelPath(filename) {
+  const name = String(filename || "").replace(/^.*[\\/]/, "");
+  const stem = name.replace(/\.json$/i, "") || "diff-rev";
+  return `${OUTPUT_DIR}/${stem}.chat.md`;
+}
+
 /** Nombre legacy fijo. */
 export const OUTPUT_FILENAME_LEGACY = `${OUTPUT_PREFIX_LEGACY}.json`;
 

package/lib/prompt.mjs

@@ -85,7 +85,8 @@ const RULES = `- Ids: themes use \`t1\`, \`t2\`, …; findings use \`f1\`, \`f2\
 - "blocking": true ONLY if the branch should not merge as-is. Use only with class "risk".
 - When several read-only lookups are independent (files, searches), batch them in the same turn if your tools allow parallel calls.
 - Write human-readable strings (intent, title, what, why, fix, notes) in Spanish. Keep enums/ids/paths/JSON keys exactly as in the schema.
-- Length is a soft target, not a check: aim for title ≤72 characters and what/why/fix ≤120 characters. Prefer clarity over shortening. Longer text is still valid. Do not rewrite the file only to shorten it.`;
+- Length is a soft target, not a check: aim for title ≤72 characters and what/why/fix ≤120 characters. Prefer clarity over shortening. Longer text is still valid. Do not rewrite the file only to shorten it.
+- If the output JSON already exists and findings have \`resolution\` ({ kind: ignored|fix|corrected, detail?: string }), preserve those fields on rewrite (coverage / edit / regenerate). Keep existing finding ids when possible; do not drop or reshuffle resolutions.`;
 
 /** @param {{ hasDiff?: boolean }} [ctx] */
 function workflowLocal(base, branch, ctx = {}) {
@@ -316,7 +317,7 @@ ${outputSchemaBlock(meta)}
 
 Include "meta" with the source/repo/branch/base above (and origin "remoteUrl" when local). "agent" and "model" are required: set "agent" to the product you are (Claude Code, Cursor, Codex, Copilot, Gemini, …) and "model" to the exact model id you are running. Do not leave placeholders or omit them; validation fails without both. "generatedAt" is optional (ISO-8601 now).
 
-Do NOT include diffs or a "files" array. The tool loads the companion \`.diff\` (or computes with git if missing) when opening the report. Do not invent hunks or paste patches into the JSON.
+Do NOT include diffs or a "files" array. The tool loads the companion \`.diff\` (or computes with git if missing) when opening the report. Do not invent hunks or paste patches into the JSON. If you are rewriting an existing review JSON, copy through any per-finding \`resolution\` already present.
 
 ${validateSection}`;
 }

package/lib/prompt.test.mjs

@@ -0,0 +1,37 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { after, test } from "node:test";
+import { buildPrompt } from "./prompt.mjs";
+import { chatRelPath } from "./output-name.mjs";
+import { companionPaths, writeHandoffChat } from "./review-dir.mjs";
+
+const tmp = mkdtempSync(join(tmpdir(), "diff-review-prompt-"));
+after(() => rmSync(tmp, { recursive: true, force: true }));
+
+test("chatRelPath uses same stem as JSON", () => {
+  assert.equal(
+    chatRelPath("diff-rev_aaaaaaaaaa_bbbbbbbbbb.json"),
+    ".diff-review/diff-rev_aaaaaaaaaa_bbbbbbbbbb.chat.md"
+  );
+});
+
+test("writeHandoffChat overwrites companion .chat.md", () => {
+  const filename = "diff-rev_aaaaaaaaaa_bbbbbbbbbb.json";
+  writeHandoffChat(tmp, filename, "# first\n");
+  writeHandoffChat(tmp, filename, "# second\n");
+  const { chat } = companionPaths(tmp, filename);
+  assert.equal(readFileSync(chat, "utf8"), "# second\n");
+  assert.equal(chatRelPath(filename), `.diff-review/${filename.replace(/\.json$/i, "")}.chat.md`);
+});
+
+test("buildPrompt tells agent to preserve finding resolution on rewrite", () => {
+  const text = buildPrompt(
+    { source: "local", repo: "/tmp/r", branch: "feat", base: "develop" },
+    { outputFilename: "diff-rev_aaaaaaaaaa_bbbbbbbbbb.json" }
+  );
+  assert.match(text, /preserve those fields on rewrite/i);
+  assert.match(text, /resolution/);
+  assert.match(text, /copy through any per-finding `resolution`/i);
+});

package/lib/review-dir.mjs

@@ -27,7 +27,7 @@ export function ensureReviewDir(repoRoot) {
   return dir;
 }
 
-/** `diff-rev_a_b.json` → `{ json, diff, session }` dentro de `.diff-review/`. */
+/** `diff-rev_a_b.json` → `{ json, diff, session, chat }` dentro de `.diff-review/`. */
 export function companionPaths(repoRoot, filename) {
   const name = basename(String(filename || ""));
   const stem = name.replace(/\.json$/i, "");
@@ -36,6 +36,8 @@ export function companionPaths(repoRoot, filename) {
     json: join(dir, name),
     diff: join(dir, `${stem}.diff`),
     session: join(dir, `${stem}.session.json`),
+    /** Transcript legible al cambiar de agente (se pisa en cada switch). */
+    chat: join(dir, `${stem}.chat.md`),
   };
 }
 
@@ -106,3 +108,14 @@ export function writeSessionRef(repoRoot, filename, ref) {
   writeFileSync(companionPaths(repoRoot, filename).session, `${JSON.stringify(full, null, 2)}\n`);
   return full;
 }
+
+/**
+ * Guarda (pisa) el transcript legible de handoff junto al JSON.
+ * @returns {string} path absoluto del `.chat.md`
+ */
+export function writeHandoffChat(repoRoot, filename, text) {
+  ensureReviewDir(repoRoot);
+  const { chat } = companionPaths(repoRoot, filename);
+  writeFileSync(chat, String(text ?? ""));
+  return chat;
+}

package/lib/review.mjs

@@ -2,6 +2,7 @@ import {
   BLOCK_OPS,
   FINDING_CLASSES,
   FINDING_KINDS,
+  FINDING_RESOLUTION_KINDS,
   FINDING_SEVERITIES,
   GROUP_KINDS,
   SKIP_REASONS,
@@ -111,6 +112,37 @@ function findingKey(finding) {
   return [finding.file, finding.line ?? "", finding.kind, finding.what].join("|");
 }
 
+/** Triage UI (`ignored` | `fix` | `corrected`); se preserva al rehidratar desde disco. */
+function normalizeResolution(raw) {
+  const kind = String(raw?.kind ?? "")
+    .trim()
+    .toLowerCase();
+  if (!FINDING_RESOLUTION_KINDS.includes(kind)) return undefined;
+  const detail = String(raw?.detail ?? "").trim();
+  return detail ? { kind, detail } : { kind };
+}
+
+function assignFindingIds(findings) {
+  const used = new Set();
+  for (const finding of findings) {
+    const id = String(finding.id || "").trim();
+    if (id && !used.has(id)) {
+      finding.id = id;
+      used.add(id);
+    } else {
+      finding.id = "";
+    }
+  }
+  let n = 1;
+  for (const finding of findings) {
+    if (finding.id) continue;
+    while (used.has(`f${n}`)) n += 1;
+    finding.id = `f${n}`;
+    used.add(finding.id);
+    n += 1;
+  }
+}
+
 function normalizeFindings(raw, { blockIds, knownPaths }) {
   const seen = new Set();
   const findings = [];
@@ -123,8 +155,9 @@ function normalizeFindings(raw, { blockIds, knownPaths }) {
     const severity = oneOf(item.severity, FINDING_SEVERITIES, "med");
     const block = String(item?.block || "").trim();
     const line = Number.isFinite(Number(item?.line)) ? Number(item.line) : null;
+    const resolution = normalizeResolution(item?.resolution);
     const finding = {
-      id: "",
+      id: String(item?.id || "").trim(),
       class: cls,
       severity,
       // Una mejora de calidad nunca frena un merge, diga lo que diga el modelo;
@@ -136,6 +169,7 @@ function normalizeFindings(raw, { blockIds, knownPaths }) {
       block: blockIds.has(block) ? block : "",
       what,
       fix: text(item.fix || item.detail, MAX.finding),
+      ...(resolution ? { resolution } : {}),
     };
     const key = findingKey(finding);
     if (seen.has(key)) continue;
@@ -150,9 +184,7 @@ function normalizeFindings(raw, { blockIds, knownPaths }) {
       rank[a.severity] - rank[b.severity] ||
       a.file.localeCompare(b.file),
   );
-  findings.forEach((finding, i) => {
-    finding.id = `f${i + 1}`;
-  });
+  assignFindingIds(findings);
   return findings;
 }
 

package/lib/review.test.mjs

@@ -130,6 +130,41 @@ test("buildReview deduplica hallazgos repetidos y limpia referencias colgadas",
   assert.equal(doc.findings[0].block, "");
 });
 
+test("buildReview preserva resolution e ids al rehidratar triage desde disco", () => {
+  const withFindings = payload();
+  withFindings.findings = [
+    {
+      id: "f2",
+      class: "quality",
+      severity: "low",
+      kind: "docs",
+      file: "src/a.ts",
+      line: 3,
+      what: "comentario viejo",
+      fix: "actualizar",
+      resolution: { kind: "ignored" },
+    },
+    {
+      id: "f1",
+      class: "risk",
+      severity: "med",
+      kind: "bug",
+      file: "src/a.ts",
+      line: 22,
+      block: "b1",
+      what: "null sin chequear",
+      fix: "guardar",
+      resolution: { kind: "corrected", detail: "null-check en parse" },
+    },
+  ];
+  const doc = buildReview({ skeleton: skeleton(), payload: withFindings });
+  const byId = Object.fromEntries(doc.findings.map((f) => [f.id, f]));
+  assert.equal(doc.findings.length, 2);
+  assert.deepEqual(byId.f1.resolution, { kind: "corrected", detail: "null-check en parse" });
+  assert.deepEqual(byId.f2.resolution, { kind: "ignored" });
+  assert.equal(byId.f1.what, "null sin chequear");
+});
+
 test("una respuesta JSON del modelo atraviesa decode, validación y normalización", () => {
   const answer = JSON.stringify({
     meta: { agent: "Claude Code", model: "claude-opus" },

package/lib/validate.mjs

@@ -8,6 +8,7 @@ export const FINDING_KINDS = [
   "missing-test", "perf", "maintainability", "docs", "other",
 ];
 export const SKIP_REASONS = ["generated", "lockfile", "format", "vendored", "binary", "trivial", "ignored"];
+export const FINDING_RESOLUTION_KINDS = ["ignored", "fix", "corrected"];
 
 /** Lo que tiene que devolver el modelo en un turno. El resto lo agrega el pipeline. */
 export const REVIEW_SCHEMA = {
@@ -77,6 +78,15 @@ export const REVIEW_SCHEMA = {
           block: { type: "string" },
           what: { type: "string", minLength: 1 },
           fix: { type: "string" },
+          resolution: {
+            type: "object",
+            required: ["kind"],
+            additionalProperties: true,
+            properties: {
+              kind: { type: "string", enum: FINDING_RESOLUTION_KINDS },
+              detail: { type: "string" },
+            },
+          },
         },
       },
     },