@jpkme/diff-review 0.1.10 → 0.1.13

package/web/build/server/chunks/agent-sessions-kcUaLhK5.js

@@ -0,0 +1,2819 @@
+import { g as getRemoteUrl, e as ensureReviewDir, w as writeDiffCache, p as readDiffCache, q as extractBranchDiff, u as loadReviewConfig, v as outputRelPath, m as makeOutputFilename, O as OUTPUT_DIR, x as writeSessionRef, h as companionPaths, d as decodePayload, t as tryResolveGitRoot, j as loadBranchDiff, y as validateAgainst, z as reviewIssues, R as REVIEW_SCHEMA, A as globMatch, C as writeDiffText } from './validate-BsTKyhsq.js';
+import { existsSync, readFileSync, statSync, accessSync, constants, readdirSync, mkdirSync, writeFileSync, copyFileSync, rmSync, realpathSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { homedir, tmpdir } from 'node:os';
+import { join, delimiter, isAbsolute, resolve, basename, dirname, normalize } from 'node:path';
+import { Writable, Readable } from 'node:stream';
+import * as acp from '@agentclientprotocol/sdk';
+
+//#region ../lib/agents.mjs
+/**
+* Agentes de código que la CLI puede lanzar con el prompt (`--agent`).
+*
+* No hay un registro de agentes en ningún SO: se detectan por nombre en el PATH más algunas rutas fijas
+* conocidas (p. ej. el Claude Code que trae la app de escritorio en Windows). El prompt viaja por stdin, así
+* no se toca el portapapeles ni se choca con el límite de largo de la línea de comandos de los shims `.cmd`.
+*/
+/**
+* @typedef {{ value: string, label: string, hint?: string }} ModelOption
+* @typedef {{ model?: string, outputFilename: string }} RunSpec
+* @typedef {{
+*   id: string,
+*   label: string,
+*   bins: string[],
+*   extraPaths?: (ctx: DetectContext) => string[],
+*   models: ModelOption[],
+*   configuredModel?: (ctx: DetectContext) => { model: string, source: string } | null,
+*   args: (spec: RunSpec) => string[],
+*   acp?: (ctx: { path: string }) => AcpLaunch,
+* }} AgentDef
+* @typedef {{ file: string, args: string[], env?: Record<string, string>, sessionMeta?: Record<string, unknown> }} AcpLaunch
+*   `env` se suma al del proceso; `sessionMeta` va como `_meta` en `session/new` / `session/load`.
+* @typedef {{ env: NodeJS.ProcessEnv, platform: NodeJS.Platform, home: string }} DetectContext
+* @typedef {{ def: AgentDef, path: string }} DetectedAgent
+*/
+/** @param {string} file */
+function readJson(file) {
+	try {
+		return JSON.parse(readFileSync(file, "utf8"));
+	} catch {
+		return null;
+	}
+}
+/** Primer `model = "..."` de nivel raíz de un TOML (antes de cualquier `[sección]`). */
+function topLevelTomlModel(text) {
+	for (const line of String(text).split(/\r?\n/)) {
+		if (/^\s*\[/.test(line)) break;
+		const m = line.match(/^\s*model\s*=\s*["']([^"']+)["']/);
+		if (m) return m[1];
+	}
+	return null;
+}
+/** Versiones tipo `2.1.286` de mayor a menor (las que no parsean, al final). */
+function byVersionDesc(a, b) {
+	const pa = a.split(".").map(Number);
+	const pb = b.split(".").map(Number);
+	for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+		const d = (pb[i] || 0) - (pa[i] || 0);
+		if (d) return Number.isNaN(d) ? 0 : d;
+	}
+	return 0;
+}
+/** `<root>/<versión>/<hash>/<exe>` → rutas, de la versión más nueva a la más vieja. */
+function versionedBinaries(root, exe) {
+	/** @type {string[]} */
+	const out = [];
+	let versions;
+	try {
+		versions = readdirSync(root).sort(byVersionDesc);
+	} catch {
+		return out;
+	}
+	for (const version of versions) {
+		let entries;
+		try {
+			entries = readdirSync(join(root, version));
+		} catch {
+			continue;
+		}
+		for (const entry of entries) out.push(join(root, version, entry, exe));
+	}
+	return out;
+}
+/**
+* Carpeta de configuración para Cursor por ACP: la del usuario sin su allowlist. Cursor aprueba solo lo que matchee
+* `permissions.allow` mirando el nombre del comando (`Shell(echo)` deja pasar `echo x > archivo`); vaciándola,
+* cada comando pasa por la política de diff-review. El login no vive ahí, así que se conserva. El modelo elegido
+* por ACP se guarda en esta carpeta y no pisa el default del usuario.
+*/
+function cursorAcpConfigDir(ctx) {
+	const c = context(ctx);
+	const userDir = c.env.CURSOR_CONFIG_DIR?.trim() || (c.env.XDG_CONFIG_HOME?.trim() ? join(c.env.XDG_CONFIG_HOME, "cursor") : join(c.home, ".cursor"));
+	const dir = join(tmpdir(), "diff-review", "cursor-config");
+	mkdirSync(dir, { recursive: true });
+	const config = readJson(join(userDir, "cli-config.json")) ?? {};
+	writeFileSync(join(dir, "cli-config.json"), JSON.stringify({
+		...config,
+		permissions: {
+			allow: [],
+			deny: config.permissions?.deny ?? []
+		},
+		approvalMode: "allowlist"
+	}, null, 2));
+	const userAcp = join(userDir, "acp-config.json");
+	if (existsSync(userAcp)) copyFileSync(userAcp, join(dir, "acp-config.json"));
+	else rmSync(join(dir, "acp-config.json"), { force: true });
+	return dir;
+}
+/** Adaptador ACP de Claude Code (antes `@zed-industries/claude-agent-acp`). */
+var CLAUDE_ACP_PACKAGE = "@agentclientprotocol/claude-agent-acp@^0.91.0";
+/** @type {AgentDef[]} */
+var AGENTS = [
+	{
+		id: "claude",
+		label: "Claude Code",
+		bins: ["claude"],
+		extraPaths: ({ env, platform, home }) => {
+			if (platform === "win32") return versionedBinaries(join(env.APPDATA || join(home, "AppData", "Roaming"), "Claude", "claude-code"), "claude.exe");
+			const paths = [join(home, ".local", "bin", "claude"), join(home, ".claude", "local", "claude")];
+			if (platform === "darwin") paths.push(...versionedBinaries(join(home, "Library", "Application Support", "Claude", "claude-code"), "claude"));
+			return paths;
+		},
+		models: [
+			{
+				value: "opus",
+				label: "opus",
+				hint: "el más capaz"
+			},
+			{
+				value: "sonnet",
+				label: "sonnet",
+				hint: "equilibrado"
+			},
+			{
+				value: "haiku",
+				label: "haiku",
+				hint: "el más rápido"
+			}
+		],
+		configuredModel: ({ env, home }) => {
+			if (env.ANTHROPIC_MODEL) return {
+				model: env.ANTHROPIC_MODEL,
+				source: "ANTHROPIC_MODEL"
+			};
+			const model = readJson(join(home, ".claude", "settings.json"))?.model;
+			return typeof model === "string" && model ? {
+				model,
+				source: "~/.claude/settings.json"
+			} : null;
+		},
+		args: ({ model, outputFilename }) => [
+			"-p",
+			...model ? ["--model", model] : [],
+			"--allowedTools",
+			"Read",
+			"Grep",
+			"Glob",
+			"Bash(git:*)",
+			"Bash(npx --yes @jpkme/diff-review validate:*)",
+			`Edit(./${outputRelPath(outputFilename)})`
+		],
+		acp: () => {
+			const local = findOnPath("claude-agent-acp", context());
+			return {
+				...local ? {
+					file: local,
+					args: []
+				} : {
+					file: "npx",
+					args: ["--yes", CLAUDE_ACP_PACKAGE]
+				},
+				sessionMeta: { claudeCode: { options: {
+					tools: [
+						"Read",
+						"Grep",
+						"Glob",
+						"Bash",
+						"Edit",
+						"Write"
+					],
+					settingSources: []
+				} } }
+			};
+		}
+	},
+	{
+		id: "codex",
+		label: "Codex",
+		bins: ["codex"],
+		models: [],
+		configuredModel: ({ home }) => {
+			try {
+				const model = topLevelTomlModel(readFileSync(join(home, ".codex", "config.toml"), "utf8"));
+				return model ? {
+					model,
+					source: "~/.codex/config.toml"
+				} : null;
+			} catch {
+				return null;
+			}
+		},
+		args: ({ model }) => [
+			"exec",
+			"--sandbox",
+			"workspace-write",
+			...model ? ["-m", model] : [],
+			"-"
+		]
+	},
+	{
+		id: "cursor",
+		label: "Cursor CLI",
+		bins: ["cursor-agent"],
+		extraPaths: ({ env, platform, home }) => platform === "win32" ? [join(env.LOCALAPPDATA || join(home, "AppData", "Local"), "cursor-agent", "cursor-agent.cmd")] : [join(home, ".local", "bin", "cursor-agent")],
+		models: [],
+		configuredModel: ({ home }) => {
+			const config = readJson(join(home, ".cursor", "cli-config.json"));
+			const id = config?.selectedModel?.modelId ?? config?.model?.modelId;
+			if (typeof id !== "string" || !id) return null;
+			return {
+				model: id === "default" ? "auto" : id,
+				source: "~/.cursor/cli-config.json"
+			};
+		},
+		args: ({ model }) => [
+			"-p",
+			"--output-format",
+			"text",
+			"--trust",
+			"--force",
+			...model ? ["--model", model] : []
+		],
+		acp: ({ path }) => ({
+			file: path,
+			args: ["acp"],
+			env: { CURSOR_CONFIG_DIR: cursorAcpConfigDir() }
+		})
+	},
+	{
+		id: "copilot",
+		label: "GitHub Copilot CLI",
+		bins: ["copilot"],
+		models: [{
+			value: "auto",
+			label: "auto",
+			hint: "Copilot elige"
+		}],
+		configuredModel: ({ env, home }) => {
+			const model = readJson(join(env.COPILOT_HOME || join(home, ".copilot"), "settings.json"))?.model;
+			const source = env.COPILOT_HOME ? "$COPILOT_HOME/settings.json" : "~/.copilot/settings.json";
+			return typeof model === "string" && model ? {
+				model,
+				source
+			} : null;
+		},
+		args: ({ model, outputFilename }) => [
+			"-s",
+			...model ? ["--model", model] : [],
+			"--allow-tool",
+			"shell(git:*)",
+			"--allow-tool",
+			"shell(npx:*)",
+			"--allow-tool",
+			`write(${outputRelPath(outputFilename)})`
+		],
+		acp: ({ path }) => ({
+			file: path,
+			args: ["--acp"]
+		})
+	},
+	{
+		id: "gemini",
+		label: "Gemini CLI",
+		bins: ["gemini"],
+		models: [],
+		configuredModel: ({ home }) => {
+			const model = readJson(join(home, ".gemini", "settings.json"))?.model;
+			const name = typeof model === "string" ? model : model?.name;
+			return typeof name === "string" && name ? {
+				model: name,
+				source: "~/.gemini/settings.json"
+			} : null;
+		},
+		args: ({ model }) => [...model ? ["-m", model] : [], "--yolo"]
+	}
+];
+/** @param {string} file @param {NodeJS.Platform} platform */
+function isExecutable(file, platform) {
+	try {
+		if (!statSync(file).isFile()) return false;
+		if (platform !== "win32") accessSync(file, constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Busca `name` en el PATH (con las extensiones de PATHEXT en Windows). */
+function findOnPath(name, { env, platform }) {
+	const dirs = String(env.PATH || env.Path || "").split(platform === "win32" ? ";" : delimiter).filter(Boolean);
+	const exts = platform === "win32" ? String(env.PATHEXT || ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean) : [""];
+	for (const dir of dirs) for (const ext of exts) {
+		const candidate = join(dir, name + ext.toLowerCase());
+		if (isExecutable(candidate, platform)) return candidate;
+	}
+	return null;
+}
+/** @param {Partial<DetectContext>} [ctx] */
+function context(ctx = {}) {
+	return {
+		env: ctx.env ?? process.env,
+		platform: ctx.platform ?? process.platform,
+		home: ctx.home ?? homedir()
+	};
+}
+/**
+* Agentes instalados, en el orden de `AGENTS`. Primero el PATH, después las rutas fijas.
+* @param {Partial<DetectContext>} [ctx]
+* @returns {DetectedAgent[]}
+*/
+function detectAgents(ctx) {
+	const c = context(ctx);
+	/** @type {DetectedAgent[]} */
+	const found = [];
+	for (const def of AGENTS) {
+		let path = null;
+		for (const bin of def.bins) {
+			path = findOnPath(bin, c);
+			if (path) break;
+		}
+		if (!path) path = (def.extraPaths?.(c) ?? []).find((p) => existsSync(p) && isExecutable(p, c.platform)) ?? null;
+		if (path) found.push({
+			def,
+			path
+		});
+	}
+	return found;
+}
+/**
+* Opciones del select de modelo: primero el default del agente (marcado como inicial), después los conocidos.
+* Si el default configurado coincide con uno conocido, no se repite.
+* @param {AgentDef} def
+* @param {Partial<DetectContext>} [ctx]
+* @returns {{ options: ModelOption[], initialValue: string }}
+*/
+function modelChoices(def, ctx) {
+	const configured = def.configuredModel?.(context(ctx)) ?? null;
+	return {
+		options: [configured ? {
+			value: "",
+			label: `Por defecto (${configured.model})`,
+			hint: configured.source
+		} : {
+			value: "",
+			label: "Por defecto del agente",
+			hint: "no se pasa --model"
+		}, ...def.models.filter((m) => m.value !== configured?.model)],
+		initialValue: ""
+	};
+}
+/** Comillas para cmd.exe (solo hace falta con los shims .cmd/.bat de npm). */
+function quoteForCmd(arg) {
+	return /^[\w./:@=-]+$/.test(arg) ? arg : `"${arg.replace(/"/g, "\"\"")}"`;
+}
+/**
+* `spawn` que también lanza los shims `.cmd`/`.bat` de npm en Windows (y `npx` a secas, que es uno de ellos).
+* @param {string} file
+* @param {string[]} args
+* @param {import('node:child_process').SpawnOptions} options
+*/
+function spawnCommand(file, args, options) {
+	const resolved = process.platform === "win32" && !/[\\/]/.test(file) ? findOnPath(file, context()) ?? file : file;
+	return process.platform === "win32" && /\.(cmd|bat)$/i.test(resolved) ? spawn([resolved, ...args].map(quoteForCmd).join(" "), {
+		...options,
+		shell: true
+	}) : spawn(resolved, args, options);
+}
+//#endregion
+//#region ../lib/acp-shell.mjs
+/**
+* Qué comandos de terminal puede correr el agente por ACP: git de solo lectura, comandos que solo leen (cat, grep,
+* find, sed -n …, y sus equivalentes de PowerShell) y el validate del paquete. Los paths tienen que quedar dentro
+* del repo.
+*
+* 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.
+*/
+/** @typedef {{ ok: true } | { ok: false, reason: string }} ShellCheck */
+/** Subcomandos de git que solo leen. */
+var GIT_READ = /* @__PURE__ */ new Set([
+	"diff",
+	"log",
+	"show",
+	"status",
+	"merge-base",
+	"rev-parse",
+	"rev-list",
+	"blame",
+	"ls-files",
+	"ls-tree",
+	"cat-file",
+	"describe",
+	"shortlog",
+	"name-rev",
+	"for-each-ref",
+	"grep",
+	"whatchanged"
+]);
+/** Flags de git que ejecutan algo o escriben archivos, en cualquier subcomando. */
+var GIT_UNSAFE_FLAG = /^(--output|--ext-diff|-O|--open-files-in-pager)(=|$)/;
+var BRANCH_LIST_FLAGS = /* @__PURE__ */ new Set([
+	"--show-current",
+	"--list",
+	"-a",
+	"--all",
+	"-r",
+	"--remotes",
+	"-v",
+	"-vv"
+]);
+var CONFIG_READ_FLAGS = /* @__PURE__ */ new Set([
+	"--get",
+	"--get-all",
+	"--get-regexp",
+	"--list",
+	"-l"
+]);
+/** Comandos que solo leen (o imprimen). Los de PowerShell van en minúscula: no distingue mayúsculas. */
+var READ_COMMANDS = /* @__PURE__ */ new Set([
+	"cat",
+	"head",
+	"tail",
+	"wc",
+	"ls",
+	"nl",
+	"sort",
+	"uniq",
+	"cut",
+	"tr",
+	"grep",
+	"egrep",
+	"fgrep",
+	"rg",
+	"find",
+	"sed",
+	"file",
+	"stat",
+	"du",
+	"diff",
+	"cmp",
+	"jq",
+	"basename",
+	"dirname",
+	"realpath",
+	"tree",
+	"which",
+	"type",
+	"pwd",
+	"echo",
+	"printf",
+	"true",
+	"get-content",
+	"gc",
+	"select-string",
+	"sls",
+	"get-childitem",
+	"gci",
+	"dir",
+	"measure-object",
+	"measure",
+	"select-object",
+	"select",
+	"sort-object",
+	"get-location",
+	"test-path",
+	"resolve-path",
+	"write-output",
+	"out-string",
+	"format-list",
+	"format-table"
+]);
+/** Comandos cuyos argumentos son texto, no paths. */
+var TEXT_ARGS = /* @__PURE__ */ new Set([
+	"echo",
+	"printf",
+	"tr",
+	"write-output",
+	"which",
+	"type"
+]);
+/** Destinos de redirección que solo descartan salida. */
+var DISCARD = /* @__PURE__ */ new Set([
+	"/dev/null",
+	"nul",
+	"$null"
+]);
+/**
+* Paths de shell Unix → forma Windows cuando la política corre en win32:
+* - Git Bash: `/c/Users/...` → `C:/Users/...`
+* - WSL: `/mnt/c/Users/...` → `C:/Users/...`
+*/
+function toNativePath(p, platform) {
+	if (platform === "win32") {
+		const wsl = /^\/mnt\/([a-zA-Z])(\/|$)(.*)$/.exec(p);
+		if (wsl) return `${wsl[1].toUpperCase()}:/${wsl[3]}`;
+		const msys = /^\/([a-zA-Z])(\/|$)(.*)$/.exec(p);
+		if (msys) return `${msys[1].toUpperCase()}:/${msys[3]}`;
+	}
+	return p;
+}
+/**
+* Resuelve symlinks cuando el path (o un ancestro) existe. Sin eso, un link
+* dentro del repo puede apuntar fuera y pasar `isInside` con solo `normalize`.
+* @param {string} path
+*/
+function canonicalPath$1(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		const parts = [];
+		let cur = normalize(path);
+		for (;;) {
+			const parent = dirname(cur);
+			if (!parent || parent === cur) return normalize(path);
+			parts.unshift(basename(cur));
+			try {
+				return resolve(realpathSync(parent), ...parts);
+			} catch {
+				cur = parent;
+			}
+		}
+	}
+}
+function isInside$1(child, root, platform) {
+	const c = normalize(canonicalPath$1(child)).replace(/[\\/]+$/, "");
+	const r = normalize(canonicalPath$1(root)).replace(/[\\/]+$/, "");
+	const [cc, rr] = platform === "win32" ? [c.toLowerCase(), r.toLowerCase()] : [c, r];
+	return cc === rr || cc.startsWith(`${rr}\\`) || cc.startsWith(`${rr}/`);
+}
+/** ¿El argumento parece un path que puede salir del repo? (absoluto, `~` o con `..`). */
+function escapingPath(arg) {
+	return /^([a-zA-Z]:[\\/]|[\\/]|~)/.test(arg) || /(^|[\\/])\.\.([\\/]|$)/.test(arg);
+}
+/**
+* Parte el comando en cadenas (separadas por `&&`, `||`, `;`, saltos de línea) de pipelines (`|`) de argv.
+* @param {string} command
+* @returns {{ ok: true, pipelines: string[][][] } | { ok: false, reason: string }}
+*/
+function tokenizeShell(command) {
+	const src = String(command ?? "");
+	/** @type {string[][][]} */
+	const pipelines = [];
+	/** @type {string[][]} */
+	let pipeline = [];
+	/** @type {string[]} */
+	let words = [];
+	let word = "";
+	let inWord = false;
+	/** @type {null | "'" | '"'} */
+	let quote = null;
+	const endWord = () => {
+		if (inWord) words.push(word);
+		word = "";
+		inWord = false;
+	};
+	const endSegment = () => {
+		endWord();
+		if (words.length) pipeline.push(words);
+		words = [];
+	};
+	const endPipeline = () => {
+		endSegment();
+		if (pipeline.length) pipelines.push(pipeline);
+		pipeline = [];
+	};
+	const fail = (reason) => ({
+		ok: false,
+		reason
+	});
+	for (let i = 0; i < src.length; i++) {
+		const ch = src[i];
+		const next = src[i + 1];
+		if (quote === "'") {
+			if (ch === "'") quote = null;
+			else word += ch;
+			continue;
+		}
+		if (quote === "\"") {
+			if (ch === "\"") quote = null;
+			else if (ch === "`") return fail("backticks");
+			else if (ch === "$" && next === "(") return fail("sustitución $(…)");
+			else if (ch === "\\" && next !== void 0 && "\"\\$`".includes(next)) {
+				word += next;
+				i++;
+			} else word += ch;
+			continue;
+		}
+		if (ch === "'" || ch === "\"") {
+			quote = ch;
+			inWord = true;
+			continue;
+		}
+		if (ch === "\\" && next !== void 0) {
+			word += next;
+			inWord = true;
+			i++;
+			continue;
+		}
+		if (ch === "`") return fail("backticks");
+		if (ch === "$" && next === "(") return fail("sustitución $(…)");
+		if (/\s/.test(ch) && ch !== "\n" && ch !== "\r") {
+			endWord();
+			continue;
+		}
+		if (ch === "\n" || ch === "\r" || ch === ";") {
+			endPipeline();
+			continue;
+		}
+		if (ch === "&" && next === "&" || ch === "|" && next === "|") {
+			endPipeline();
+			i++;
+			continue;
+		}
+		if (ch === "|") {
+			endSegment();
+			continue;
+		}
+		if (ch === ">" || ch === "&" && next === ">") {
+			if (ch === "&") i++;
+			const fd = inWord && /^[12]$/.test(word) ? word : "";
+			if (inWord && !fd) return fail("redirección");
+			word = "";
+			inWord = false;
+			let j = i + 1;
+			if (src[j] === ">") j++;
+			if (src[j] === "&" && /[12]/.test(src[j + 1] ?? "")) {
+				i = j + 1;
+				continue;
+			}
+			while (src[j] === " " || src[j] === "	") j++;
+			let target = "";
+			while (j < src.length && !/[\s;|&<>]/.test(src[j])) target += src[j++];
+			if (!DISCARD.has(target.toLowerCase())) return fail(`redirección a ${target || "archivo"}`);
+			i = j - 1;
+			continue;
+		}
+		if (ch === "<") return fail("redirección de entrada");
+		if (ch === "&") return fail("comando en segundo plano (&)");
+		word += ch;
+		inWord = true;
+	}
+	if (quote) return fail("comillas sin cerrar");
+	endPipeline();
+	return {
+		ok: true,
+		pipelines
+	};
+}
+/**
+* @param {string} arg
+* @param {{ repo: string, platform: NodeJS.Platform }} ctx
+* @returns {ShellCheck}
+*/
+function checkPath(arg, { repo, platform }) {
+	if (DISCARD.has(arg.toLowerCase())) return { ok: true };
+	const native = toNativePath(arg.replace(/^~(?=[\\/]|$)/, "/__home__"), platform);
+	return isInside$1(isAbsolute(native) ? native : resolve(repo, native), repo, platform) ? { ok: true } : {
+		ok: false,
+		reason: `path fuera del repo: ${arg}`
+	};
+}
+/** Argumentos (y valores de `--opt=valor`) que parecen paths que salen del repo deben quedar adentro. */
+function checkArgsInside(args, ctx) {
+	for (const arg of args) {
+		const value = arg.startsWith("-") ? arg.includes("=") ? arg.slice(arg.indexOf("=") + 1) : "" : arg;
+		if (value && escapingPath(value)) {
+			const res = checkPath(value, ctx);
+			if (!res.ok) return res;
+		}
+	}
+	return { ok: true };
+}
+/** @param {string[]} argv @returns {ShellCheck} */
+function checkGit(argv, ctx) {
+	let i = 1;
+	while (argv[i]?.startsWith("-")) {
+		const flag = argv[i];
+		if (flag === "--no-pager" || flag === "-P") i++;
+		else if (flag === "-C") {
+			const res = checkPath(argv[i + 1] ?? "", ctx);
+			if (!res.ok) return res;
+			i += 2;
+		} else return {
+			ok: false,
+			reason: `opción global de git no permitida: ${flag}`
+		};
+	}
+	const sub = argv[i] ?? "";
+	const rest = argv.slice(i + 1);
+	const unsafe = rest.find((w) => GIT_UNSAFE_FLAG.test(w));
+	if (unsafe) return {
+		ok: false,
+		reason: `git ${sub} ${unsafe}`
+	};
+	if (GIT_READ.has(sub)) return { ok: true };
+	if (sub === "branch" && rest.every((w) => BRANCH_LIST_FLAGS.has(w))) return { ok: true };
+	if (sub === "remote" && (rest.length === 0 || rest.length === 1 && rest[0] === "-v" || rest[0] === "get-url")) return { ok: true };
+	if (sub === "config" && rest.some((w) => CONFIG_READ_FLAGS.has(w))) return { ok: true };
+	return {
+		ok: false,
+		reason: `git ${sub || "(sin subcomando)"} no es de solo lectura`
+	};
+}
+/** @param {string[]} argv @returns {ShellCheck} */
+function checkReadCommand(name, argv, ctx) {
+	const args = argv.slice(1);
+	if (name === "sort" && args.some((a) => /^(-o|--output)/.test(a))) return {
+		ok: false,
+		reason: "sort -o escribe un archivo"
+	};
+	if (name === "uniq" && args.filter((a) => !a.startsWith("-")).length > 1) return {
+		ok: false,
+		reason: "uniq con archivo de salida"
+	};
+	if (name === "find" && args.some((a) => /^-(exec|execdir|ok|okdir|delete|fprint|fprint0|fprintf|fls)$/.test(a))) return {
+		ok: false,
+		reason: "find que ejecuta o escribe"
+	};
+	if (name === "rg" && args.some((a) => /^--pre(-glob)?(=|$)/.test(a))) return {
+		ok: false,
+		reason: "rg --pre ejecuta comandos"
+	};
+	if (name === "sed") {
+		if (!args.includes("-n") || args.some((a) => /^(-i|--in-place|-e|-f|--expression|--file)/.test(a))) return {
+			ok: false,
+			reason: "sed solo como `sed -n 'N,Mp'`"
+		};
+		const script = args.find((a) => !a.startsWith("-"));
+		if (!script || !/^\s*(\d+|\$)(\s*,\s*(\d+|\$))?\s*p\s*$/.test(script)) return {
+			ok: false,
+			reason: "sed solo como `sed -n 'N,Mp'`"
+		};
+		return checkArgsInside(args.filter((a) => a !== script), ctx);
+	}
+	if (TEXT_ARGS.has(name)) return { ok: true };
+	return checkArgsInside(args, ctx);
+}
+/** El validate del paquete (por npx o con el bin instalado), con el archivo como único argumento. */
+function isValidate(argv) {
+	const line = argv.join(" ");
+	return /^(?:npx\s+(?:--yes\s+|-y\s+)?@jpkme\/diff-review(?:@[\w.^~-]+)?|diff-review)\s+validate\s+\S+$/.test(line);
+}
+/**
+* `mkdir` / `md` / `New-Item -ItemType Directory` solo bajo `.diff-review/` del repo.
+* @param {string[]} argv
+* @param {{ repo: string, platform: NodeJS.Platform }} ctx
+* @returns {ShellCheck | null} null = no es este caso
+*/
+function checkReviewDirMkdir(argv, ctx) {
+	const name = argv[0].toLowerCase();
+	const reviewRoot = resolve(ctx.repo, ".diff-review");
+	/** @param {string} arg */
+	const underReviewDir = (arg) => {
+		const native = toNativePath(String(arg || "").replace(/^~(?=[\\/]|$)/, "/__home__"), ctx.platform);
+		return isInside$1(isAbsolute(native) ? native : resolve(ctx.repo, native), reviewRoot, ctx.platform);
+	};
+	if (name === "mkdir" || name === "md") {
+		const paths = argv.slice(1).filter((a) => !a.startsWith("-"));
+		if (!paths.length || !paths.every(underReviewDir)) return {
+			ok: false,
+			reason: "mkdir solo permitido bajo .diff-review/"
+		};
+		return { ok: true };
+	}
+	if (name === "new-item") {
+		const joined = argv.join(" ").toLowerCase();
+		if (!/-itemtype\s+directory\b/.test(joined) && !/\b-type\s+directory\b/.test(joined)) return null;
+		const paths = argv.slice(1).filter((a) => !a.startsWith("-") && !/^(directory|file)$/i.test(a));
+		if (!paths.length || !paths.every(underReviewDir)) return {
+			ok: false,
+			reason: "New-Item Directory solo permitido bajo .diff-review/"
+		};
+		return { ok: true };
+	}
+	return null;
+}
+/**
+* @param {string} command
+* @param {{ repo?: string, platform?: NodeJS.Platform }} [opts]
+* @returns {ShellCheck}
+*/
+function checkShell(command, { repo, platform = process.platform } = {}) {
+	const parsed = tokenizeShell(command);
+	if (!parsed.ok) return parsed;
+	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) {
+		const name = argv[0].toLowerCase();
+		if (argv[0].includes("=")) return {
+			ok: false,
+			reason: `variables de entorno en el comando: ${argv[0]}`
+		};
+		/** @type {ShellCheck} */
+		let res;
+		if (name === "cd" || name === "set-location") res = repo && argv[1] ? checkPath(argv[1], ctx) : {
+			ok: false,
+			reason: "cd fuera del repo"
+		};
+		else if (name === "git") res = checkGit(argv, ctx);
+		else if (name === "npx" || name === "diff-review") res = isValidate(argv) ? { ok: true } : {
+			ok: false,
+			reason: `${argv.join(" ")}`
+		};
+		else if (READ_COMMANDS.has(name)) res = checkReadCommand(name, argv, ctx);
+		else res = checkReviewDirMkdir(argv, ctx) ?? {
+			ok: false,
+			reason: `${argv[0]} no está permitido`
+		};
+		if (!res.ok) return res;
+	}
+	return { ok: true };
+}
+//#endregion
+//#region ../lib/acp-policy.mjs
+/**
+* Qué puede hacer el agente cuando corre por ACP. Cada `session/request_permission` pasa por acá: no hay nadie
+* mirando la terminal para aprobar, así que la política es una allowlist (leer, comandos de solo lectura y escribir
+* el JSON de salida en `.diff-review/`) y todo lo demás se rechaza.
+*
+* Ojo: el agente solo pide permiso para lo que *su* configuración no aprueba sola (p. ej. Claude Code aplica la
+* allowlist de `~/.claude/settings.json` antes de preguntar). Esto acota lo que pide, no lo que el usuario ya
+* habilitó en su agente.
+*/
+/**
+* @typedef {"review" | "ask" | "edit"} PolicyMode
+*   review = generar el JSON; ask = preguntas (no puede escribir nada); edit = modificar el JSON.
+* @typedef {{ repo: string, outputFilename: string, mode: PolicyMode }} PolicyContext
+* @typedef {{
+*   kind?: string | null,
+*   title?: string | null,
+*   rawInput?: unknown,
+*   locations?: { path: string }[] | null,
+*   content?: { type: string, path?: string }[] | null,
+* }} ToolCallLike
+* @typedef {{ allow: boolean, reason: string }} Decision
+*/
+/** @param {string} a @param {string} b */
+function samePath(a, b, platform = process.platform) {
+	const na = normalize(a);
+	const nb = normalize(b);
+	return platform === "win32" ? na.toLowerCase() === nb.toLowerCase() : na === nb;
+}
+/**
+* Resuelve symlinks cuando el path (o un ancestro) existe. Sin eso, un link dentro del repo
+* puede apuntar fuera y pasar `isInside` con solo `resolve`.
+* @param {string} path
+*/
+function canonicalPath(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		const parts = [];
+		let cur = normalize(path);
+		for (;;) {
+			const parent = dirname(cur);
+			if (!parent || parent === cur) return normalize(path);
+			parts.unshift(basename(cur));
+			try {
+				return resolve(realpathSync(parent), ...parts);
+			} catch {
+				cur = parent;
+			}
+		}
+	}
+}
+/** @param {string} child @param {string} root */
+function isInside(child, root, platform = process.platform) {
+	const c = normalize(canonicalPath(child));
+	const r = normalize(canonicalPath(root)).replace(/[\\/]+$/, "");
+	const [cc, rr] = platform === "win32" ? [c.toLowerCase(), r.toLowerCase()] : [c, r];
+	return cc === rr || cc.startsWith(`${rr}\\`) || cc.startsWith(`${rr}/`);
+}
+/** Paths que toca la tool call (`locations`, diffs de `content` y los campos típicos de `rawInput`). */
+function toolCallPaths(toolCall, repo) {
+	const raw = toolCall.rawInput && typeof toolCall.rawInput === "object" ? toolCall.rawInput : {};
+	const candidates = [
+		...(toolCall.locations ?? []).map((l) => l?.path),
+		...(toolCall.content ?? []).map((c) => c?.type === "diff" ? c.path : void 0),
+		raw.file_path,
+		raw.path,
+		raw.filePath,
+		raw.notebook_path
+	];
+	const out = [];
+	for (const c of candidates) {
+		if (typeof c !== "string" || !c.trim()) continue;
+		const abs = isAbsolute(c) ? c : resolve(repo, c);
+		if (!out.some((p) => samePath(p, abs))) out.push(abs);
+	}
+	return out;
+}
+/** @param {unknown} rawInput */
+function commandOf(rawInput) {
+	if (!rawInput || typeof rawInput !== "object") return "";
+	const cmd = rawInput.command;
+	if (Array.isArray(cmd)) return cmd.map(String).join(" ");
+	return typeof cmd === "string" ? cmd : "";
+}
+/**
+* Comando de shell que la política evalúa (rawInput, backticks o título entero).
+* Cursor a veces envuelve el script con `@…@` en el título.
+* @param {ToolCallLike} toolCall
+*/
+function toolCallCommand(toolCall) {
+	const fromRaw = commandOf(toolCall.rawInput).trim();
+	if (fromRaw) return fromRaw;
+	const title = String(toolCall.title ?? "").trim();
+	const tick = /^`([\s\S]+)`$/.exec(title);
+	if (tick) return tick[1].trim();
+	const at = /^@\s*([\s\S]*?)\s*@$/.exec(title);
+	if (at) return at[1].trim();
+	return title;
+}
+/**
+* Etiqueta corta del agente si el título no es el comando mismo.
+* @param {ToolCallLike} toolCall
+* @param {string} [command]
+*/
+function toolCallLabel(toolCall, command = toolCallCommand(toolCall)) {
+	const title = String(toolCall.title ?? "").trim();
+	if (!title) return "";
+	if (/^`[\s\S]+`$/.test(title) || /^@\s*[\s\S]*?\s*@$/.test(title)) return "";
+	const norm = (s) => s.replace(/\s+/g, " ").trim();
+	if (command && norm(title) === norm(command)) return "";
+	if (command && command.length >= 24 && title.includes(command.slice(0, 24))) return "";
+	return title;
+}
+/**
+* Motivo de denegación legible en la UI de permisos.
+* @param {string} reason
+*/
+function humanizePolicyReason(reason) {
+	const r = String(reason || "").trim();
+	if (!r) return "La política bloqueó este pedido.";
+	let m;
+	if (m = /^(.+?) no está permitido$/.exec(r)) return `La política bloqueó «${m[1]}» (no está en la allowlist de comandos).`;
+	if (m = /^variables de entorno en el comando:\s*(.*)$/s.exec(r)) return `La política interpretó parte del comando como variable de entorno (${String(m[1] || "?").trim().slice(0, 40)}) y lo bloqueó.`;
+	if (m = /^path fuera del repo:\s*(.*)$/s.exec(r)) return `El path queda fuera del repo: ${m[1]}`;
+	if (m = /^lectura fuera del repo:\s*(.*)$/s.exec(r)) return `Lectura fuera del repo: ${m[1]}`;
+	if (m = /^opción global de git no permitida:\s*(.*)$/s.exec(r)) return `Opción de git no permitida: ${m[1]}`;
+	if (r.startsWith("git ")) return `Comando git no permitido por la política: ${r}`;
+	if (r.startsWith("solo se puede escribir") || r.includes("sin path") || r.startsWith("modo pregunta")) return r;
+	return `La política bloqueó el pedido: ${r}`;
+}
+/**
+* @param {ToolCallLike} toolCall
+* @param {PolicyContext} ctx
+* @returns {Decision}
+*/
+function decidePermission(toolCall, { repo, outputFilename, mode }) {
+	const kind = toolCall.kind ?? "other";
+	const paths = toolCallPaths(toolCall, repo);
+	if (kind === "read" || kind === "search") {
+		if (!paths.length) return {
+			allow: false,
+			reason: `${kind === "search" ? "búsqueda" : "lectura"} sin path`
+		};
+		const outside = paths.find((p) => !isInside(p, repo));
+		return outside ? {
+			allow: false,
+			reason: `lectura fuera del repo: ${outside}`
+		} : {
+			allow: true,
+			reason: "lectura"
+		};
+	}
+	if (kind === "think") return {
+		allow: true,
+		reason: "pensar"
+	};
+	if (kind === "execute") {
+		const check = checkShell(toolCallCommand(toolCall), { repo });
+		return check.ok ? {
+			allow: true,
+			reason: "comando de solo lectura"
+		} : {
+			allow: false,
+			reason: check.reason
+		};
+	}
+	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`
+		};
+		const target = resolve(repo, outputRelPath(outputFilename));
+		const outside = paths.find((p) => !samePath(canonicalPath(p), canonicalPath(target)));
+		return outside ? {
+			allow: false,
+			reason: `solo se puede escribir ${outputRelPath(outputFilename)} (no ${outside})`
+		} : {
+			allow: true,
+			reason: `escritura de ${outputRelPath(outputFilename)}`
+		};
+	}
+	return {
+		allow: false,
+		reason: `${kind} no permitido: ${toolCall.title ?? "?"}`
+	};
+}
+/**
+* Respuesta ACP para una decisión del usuario / política.
+* - allow + once → `allow_once` (la política se vuelve a evaluar en el próximo pedido).
+* - allow + always → `allow_always` si el agente la ofrece; si no, cae a `allow_once`.
+* @param {{ optionId: string, kind: string }[]} options
+* @param {boolean} allow
+* @param {{ always?: boolean }} [opts]
+*/
+function permissionOutcome(options, allow, opts = {}) {
+	const always = Boolean(opts.always);
+	const option = (allow ? always ? ["allow_always", "allow_once"] : ["allow_once"] : ["reject_once", "reject_always"]).map((kind) => options.find((o) => o.kind === kind)).find(Boolean);
+	return option ? { outcome: {
+		outcome: "selected",
+		optionId: option.optionId
+	} } : { outcome: { outcome: "cancelled" } };
+}
+//#endregion
+//#region ../lib/agent-login.mjs
+/**
+* Login de agentes ACP: mensajes claros + abrir una terminal interactiva cuando se pueda.
+*/
+/**
+* @typedef {{ bin: string, args: string[], display: string }} LoginCommand
+*/
+/**
+* Comando de login interactivo por agente (null = no hay CLI de login, p. ej. Cursor app).
+* @param {string} agentId
+* @returns {LoginCommand | null}
+*/
+function loginCommand(agentId) {
+	switch (agentId) {
+		case "claude": return {
+			bin: "claude",
+			args: ["/login"],
+			display: "claude /login"
+		};
+		case "copilot": return {
+			bin: "gh",
+			args: ["auth", "login"],
+			display: "gh auth login"
+		};
+		case "codex": return {
+			bin: "codex",
+			args: ["login"],
+			display: "codex login"
+		};
+		case "gemini": return {
+			bin: "gemini",
+			args: [],
+			display: "gemini"
+		};
+		default: return null;
+	}
+}
+/** @param {string} text */
+function looksLikeAuthFailure(text) {
+	const s = String(text || "").toLowerCase();
+	return /(not\s+)?auth|login|unauthor|not logged|sign[\s-]?in|credentials|token.*(invalid|expired|missing)|please\s+run/.test(s);
+}
+/**
+* Mensaje en español si el agente murió / falló por falta de login.
+* @param {string} agentId
+* @param {string} agentLabel
+* @param {string} detail
+* @returns {string | null}
+*/
+function authFailureMessage$1(agentId, agentLabel, detail) {
+	if (!looksLikeAuthFailure(detail)) return null;
+	const cmd = loginCommand(agentId);
+	if (agentId === "cursor") return `${agentLabel} no está autenticado. Iniciá sesión en la app de Cursor y reintentá.`;
+	if (cmd) return `${agentLabel} no está autenticado. Corré \`${cmd.display}\` en una terminal y reintentá.`;
+	return `${agentLabel} no está autenticado. Revisá el login del agente y reintentá.`;
+}
+/**
+* Abre una terminal nueva con el login del agente (Windows / macOS / Linux).
+* @param {string} agentId
+* @returns {{ display: string }}
+*/
+function openLoginTerminal(agentId) {
+	const cmd = loginCommand(agentId);
+	if (!cmd) throw new Error(agentId === "cursor" ? "Cursor se autentica desde la app de escritorio, no desde una terminal." : "Este agente no tiene un comando de login conocido.");
+	const platform = process.platform;
+	if (platform === "win32") spawn("cmd.exe", [
+		"/c",
+		"start",
+		`${cmd.bin} login`,
+		"cmd.exe",
+		"/k",
+		cmd.bin,
+		...cmd.args
+	], {
+		detached: true,
+		stdio: "ignore",
+		windowsHide: false
+	}).unref();
+	else if (platform === "darwin") spawn("osascript", ["-e", `tell application "Terminal" to do script ${JSON.stringify(`${cmd.bin} ${cmd.args.join(" ")}`.trim())}`], {
+		detached: true,
+		stdio: "ignore"
+	}).unref();
+	else {
+		const line = `${cmd.bin} ${cmd.args.join(" ")}`.trim();
+		const tried = [
+			["x-terminal-emulator", [
+				"-e",
+				"bash",
+				"-lc",
+				`${line}; exec bash`
+			]],
+			["gnome-terminal", [
+				"--",
+				"bash",
+				"-lc",
+				`${line}; exec bash`
+			]],
+			["konsole", [
+				"-e",
+				"bash",
+				"-lc",
+				`${line}; exec bash`
+			]],
+			["xterm", [
+				"-e",
+				"bash",
+				"-lc",
+				`${line}; exec bash`
+			]]
+		];
+		let ok = false;
+		for (const [bin, args] of tried) try {
+			spawn(bin, args, {
+				detached: true,
+				stdio: "ignore"
+			}).unref();
+			ok = true;
+			break;
+		} catch {}
+		if (!ok) throw new Error(`No pude abrir una terminal. Corré a mano: ${cmd.display}`);
+	}
+	return { display: cmd.display };
+}
+/** @returns {string} */
+function modelsCachePath(home = homedir()) {
+	return join(home, ".diff-review", "models-cache.json");
+}
+/**
+* @param {string} agentId
+* @param {{ home?: string, now?: number, ttlMs?: number }} [opts]
+* @returns {{ models: { value: string, name: string }[], currentModel: string, fetchedAt: string } | null}
+*/
+function readModelsCache(agentId, opts = {}) {
+	const id = String(agentId || "").trim();
+	if (!id) return null;
+	const path = modelsCachePath(opts.home);
+	let root;
+	try {
+		root = JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return null;
+	}
+	const entry = root?.agents?.[id];
+	if (!entry || !Array.isArray(entry.models)) return null;
+	const fetchedAt = Date.parse(String(entry.fetchedAt || ""));
+	if (!Number.isFinite(fetchedAt)) return null;
+	const ttl = opts.ttlMs ?? 864e5;
+	if ((opts.now ?? Date.now()) - fetchedAt > ttl) return null;
+	return {
+		models: entry.models.filter((m) => m && typeof m.value === "string").map((m) => ({
+			value: m.value,
+			name: String(m.name ?? m.value)
+		})),
+		currentModel: String(entry.currentModel ?? ""),
+		fetchedAt: new Date(fetchedAt).toISOString()
+	};
+}
+/**
+* @param {string} agentId
+* @param {{ models: { value: string, name: string }[], currentModel?: string }} data
+* @param {{ home?: string, now?: number }} [opts]
+*/
+function writeModelsCache(agentId, data, opts = {}) {
+	const id = String(agentId || "").trim();
+	if (!id || !Array.isArray(data?.models) || !data.models.length) return;
+	const path = modelsCachePath(opts.home);
+	let root = {
+		version: 1,
+		agents: {}
+	};
+	try {
+		if (existsSync(path)) root = {
+			...root,
+			...JSON.parse(readFileSync(path, "utf8"))
+		};
+	} catch {}
+	if (!root.agents || typeof root.agents !== "object") root.agents = {};
+	root.agents[id] = {
+		fetchedAt: new Date(opts.now ?? Date.now()).toISOString(),
+		currentModel: String(data.currentModel ?? ""),
+		models: data.models.map((m) => ({
+			value: String(m.value),
+			name: String(m.name ?? m.value)
+		}))
+	};
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, `${JSON.stringify(root, null, 2)}\n`);
+}
+//#endregion
+//#region ../lib/acp.mjs
+/**
+* Sesión con un agente por ACP (Agent Client Protocol): JSON-RPC por stdin/stdout del proceso del agente.
+*
+* A diferencia de `runAgent` (una vuelta headless), el proceso queda vivo: la misma sesión sirve para generar la
+* review y después para las preguntas y los cambios que se le pidan desde la web. Cada pedido de permiso pasa por
+* `decide` (ver `acp-policy.mjs`): no hay nadie mirando una terminal para aprobar.
+*/
+/** El agente tiene un modo ACP declarado (no todos los agentes lo traen). */
+function supportsAcp(agent) {
+	return typeof agent?.def?.acp === "function";
+}
+/**
+* Opción de modelo (`configOptions` con id/categoría "model") de la respuesta de `session/new` o `session/load`.
+* @param {{ configOptions?: any[] | null }} response
+*/
+function modelConfig(response) {
+	const option = (response?.configOptions ?? []).find((o) => o?.category === "model" || o?.id === "model");
+	if (!option || option.type !== "select") return null;
+	const flat = (option.options ?? []).flatMap((o) => Array.isArray(o?.options) ? o.options : [o]);
+	return {
+		configId: String(option.id),
+		current: String(option.currentValue ?? ""),
+		options: flat.filter((o, i) => o && typeof o.value === "string" && flat.findIndex((x) => x?.value === o.value) === i).map((o) => ({
+			value: o.value,
+			name: String(o.name ?? o.value)
+		}))
+	};
+}
+/** Tiempo máximo para initialize + session/new|load (+ set model). */
+var ACP_START_TIMEOUT_MS = 9e4;
+/**
+* Lanza el agente en modo ACP, negocia y abre (o retoma) una sesión.
+* @param {DetectedAgent} agent
+* @param {AcpSessionOptions} opts
+* @returns {Promise<AcpSession>}
+*/
+async function startAcpSession(agent, opts) {
+	if (!supportsAcp(agent)) throw new Error(`${agent.def.label} no tiene modo ACP.`);
+	const { file, args, env, sessionMeta } = agent.def.acp({ path: agent.path });
+	const child = spawnCommand(file, args, {
+		cwd: opts.cwd,
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		],
+		...env ? { env: {
+			...process.env,
+			...env
+		} } : {}
+	});
+	let stderr = "";
+	child.stderr?.on("data", (chunk) => {
+		stderr = (stderr + String(chunk)).slice(-4e3);
+	});
+	child.stdin?.on("error", () => {});
+	const conn = acp.client({ name: "diff-review" }).onRequest(acp.methods.client.session.requestPermission, async (ctx) => {
+		const toolCall = ctx.params.toolCall;
+		const decision = safeDecide(opts.decide, toolCall);
+		if (decision.allow) {
+			opts.onPermission?.(toolCall, decision);
+			return permissionOutcome(ctx.params.options, true);
+		}
+		let allow = false;
+		let always = false;
+		if (opts.onDeniedPermission) try {
+			const answer = await opts.onDeniedPermission(toolCall, decision);
+			if (answer && typeof answer === "object") {
+				allow = Boolean(answer.allow);
+				always = Boolean(answer.always);
+			} else allow = Boolean(answer);
+		} catch {
+			allow = false;
+			always = false;
+		}
+		const final = {
+			allow,
+			reason: allow ? always ? "permitido siempre" : "permitido por el usuario" : decision.reason
+		};
+		opts.onPermission?.(toolCall, final);
+		return permissionOutcome(ctx.params.options, allow, { always });
+	}).onNotification(acp.methods.client.session.update, (ctx) => {
+		opts.onUpdate?.(ctx.params.update);
+	}).connect(acp.ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout)));
+	new Promise((resolve) => {
+		child.once("error", (err) => {
+			stderr += `\n${err.message}`;
+			resolve(null);
+		});
+		child.once("exit", (code) => resolve(code));
+	}).then((code) => {
+		conn.close(/* @__PURE__ */ new Error(`${agent.def.label} terminó (código ${code ?? "?"}).`));
+		opts.onExit?.({
+			code,
+			stderr
+		});
+	});
+	const close = () => {
+		conn.close();
+		if (child.exitCode == null) child.kill();
+	};
+	const timeoutMs = Math.max(15e3, Number(opts.timeoutMs) || ACP_START_TIMEOUT_MS);
+	let timedOut = false;
+	const timer = setTimeout(() => {
+		timedOut = true;
+		close();
+	}, timeoutMs);
+	try {
+		const init = await conn.agent.request(acp.methods.agent.initialize, {
+			protocolVersion: acp.PROTOCOL_VERSION,
+			clientCapabilities: {
+				fs: {
+					readTextFile: false,
+					writeTextFile: false
+				},
+				terminal: false
+			},
+			clientInfo: {
+				name: "diff-review",
+				version: "0"
+			}
+		});
+		/** Métodos donde el agente maneja el login por `authenticate` (no terminal interactiva). */
+		const agentAuthMethods = (Array.isArray(init.authMethods) ? init.authMethods : []).filter((m) => m && (!m.type || m.type === "agent") && m.id);
+		/** Si session/new falla por auth, pedimos `authenticate` una vez y reintentamos. */
+		const tryAuthenticate = async () => {
+			for (const method of agentAuthMethods) try {
+				await conn.agent.request(acp.methods.agent.authenticate, { methodId: method.id });
+				return true;
+			} catch {}
+			return false;
+		};
+		const openNewSession = async () => {
+			try {
+				return await conn.agent.request(acp.methods.agent.session.new, {
+					cwd: opts.cwd,
+					mcpServers: [],
+					...sessionMeta ? { _meta: sessionMeta } : {}
+				});
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				if (agentAuthMethods.length && looksLikeAuthFailure(msg) && await tryAuthenticate()) return await conn.agent.request(acp.methods.agent.session.new, {
+					cwd: opts.cwd,
+					mcpServers: [],
+					...sessionMeta ? { _meta: sessionMeta } : {}
+				});
+				throw err;
+			}
+		};
+		let sessionId = "";
+		let response;
+		let resumed = false;
+		if (opts.resumeSessionId && init.agentCapabilities?.loadSession) try {
+			response = await conn.agent.request(acp.methods.agent.session.load, {
+				sessionId: opts.resumeSessionId,
+				cwd: opts.cwd,
+				mcpServers: [],
+				...sessionMeta ? { _meta: sessionMeta } : {}
+			});
+			sessionId = opts.resumeSessionId;
+			resumed = true;
+		} catch {}
+		if (!resumed) {
+			response = await openNewSession();
+			sessionId = response.sessionId;
+		}
+		const models = modelConfig(response);
+		let currentModel = models?.current ?? "";
+		/**
+		* @param {string} model
+		* @returns {Promise<{ currentModel: string, warning?: string }>}
+		*/
+		const setModel = async (model) => {
+			const wanted = String(model || "").trim();
+			if (!wanted || wanted === currentModel) return { currentModel };
+			if (!models) return {
+				currentModel,
+				warning: `El agente no deja elegir el modelo por ACP; usa el suyo.`
+			};
+			if (!models.options.some((o) => o.value === wanted)) return {
+				currentModel,
+				warning: `El agente no ofrece el modelo "${wanted}"; sigue con "${currentModel}".`
+			};
+			await conn.agent.request(acp.methods.agent.session.setConfigOption, {
+				sessionId,
+				configId: models.configId,
+				value: wanted
+			});
+			currentModel = wanted;
+			return { currentModel };
+		};
+		let modelWarning;
+		const initialWanted = String(opts.model || "").trim();
+		if (initialWanted) {
+			const applied = await setModel(initialWanted);
+			if (applied.warning) modelWarning = applied.warning;
+		}
+		clearTimeout(timer);
+		return {
+			sessionId,
+			resumed,
+			models: models?.options ?? [],
+			get currentModel() {
+				return currentModel;
+			},
+			...modelWarning ? { modelWarning } : {},
+			setModel,
+			prompt: async (text) => {
+				const res = await conn.agent.request(acp.methods.agent.session.prompt, {
+					sessionId,
+					prompt: [{
+						type: "text",
+						text
+					}]
+				});
+				return { stopReason: String(res.stopReason) };
+			},
+			cancel: () => conn.agent.notify(acp.methods.agent.session.cancel, { sessionId }),
+			close,
+			closed: conn.closed,
+			stderrTail: () => stderr
+		};
+	} catch (err) {
+		clearTimeout(timer);
+		close();
+		const tail = stderr.trim().split(/\r?\n/).slice(-8).join("\n");
+		if (timedOut) {
+			const msg = `Timeout (${Math.round(timeoutMs / 1e3)}s) al lanzar ${agent.def.label}. ¿Está autenticado el CLI?`;
+			throw new Error(tail ? `${msg}\n${tail}` : msg);
+		}
+		const reason = err instanceof Error ? err.message : String(err);
+		throw new Error(tail ? `${reason}\n${tail}` : reason);
+	}
+}
+/**
+* Modelos ACP con caché en `~/.diff-review/models-cache.json` (TTL 24h).
+* @param {DetectedAgent} agent
+* @param {{ cwd: string, timeoutMs?: number, force?: boolean }} opts
+* @returns {Promise<{ models: ModelOption[], currentModel: string, fromCache: boolean }>}
+*/
+async function listAcpModelsCached(agent, opts) {
+	if (!Boolean(opts?.force)) {
+		const hit = readModelsCache(agent.def.id);
+		if (hit) return {
+			models: hit.models,
+			currentModel: hit.currentModel,
+			fromCache: true
+		};
+	}
+	const result = await listAcpModels(agent, opts);
+	if (result.models.length) writeModelsCache(agent.def.id, result);
+	return {
+		...result,
+		fromCache: false
+	};
+}
+/**
+* Modelos que ofrece el agente por ACP (abre una sesión, lee las opciones y la cierra; no manda ningún prompt).
+* @param {DetectedAgent} agent
+* @param {{ cwd: string, timeoutMs?: number }} opts
+* @returns {Promise<{ models: ModelOption[], currentModel: string }>}
+*/
+async function listAcpModels(agent, { cwd, timeoutMs = 45e3 }) {
+	const ms = Math.max(5e3, Number(timeoutMs) || 45e3);
+	/** @type {AcpSession | null} */
+	let session = null;
+	const pending = startAcpSession(agent, {
+		cwd,
+		decide: () => ({
+			allow: false,
+			reason: "solo se listan modelos"
+		})
+	}).then((s) => {
+		session = s;
+		return s;
+	});
+	const timeout = new Promise((_, reject) => {
+		setTimeout(() => {
+			reject(/* @__PURE__ */ new Error(`Timeout (${Math.round(ms / 1e3)}s) al consultar modelos de ${agent.def.label}. Reintentá en unos segundos.`));
+		}, ms);
+	});
+	try {
+		const opened = await Promise.race([pending, timeout]);
+		const out = {
+			models: opened.models,
+			currentModel: opened.currentModel
+		};
+		opened.close();
+		session = null;
+		return out;
+	} catch (err) {
+		pending.then((s) => s.close()).catch(() => {});
+		try {
+			session?.close();
+		} catch {}
+		throw err;
+	}
+}
+/** Un error en la política no puede colgar al agente esperando respuesta: se rechaza. */
+function safeDecide(decide, toolCall) {
+	try {
+		return decide(toolCall);
+	} catch (err) {
+		return {
+			allow: false,
+			reason: `error en la política: ${err instanceof Error ? err.message : err}`
+		};
+	}
+}
+//#endregion
+//#region ../lib/check-report.mjs
+/**
+* Valida un JSON de review y arma un texto accionable para el agente.
+*/
+/** Raíz del repo a partir del JSON (`.diff-review/foo.json` → parent, o la carpeta del archivo legacy). */
+function repoRootFromReviewFile(absJson) {
+	const dir = dirname(absJson);
+	return basename(dir) === ".diff-review" ? dirname(dir) : dir;
+}
+var MISSING_LIMIT = 40;
+/**
+* @param {unknown} payload
+* @param {string[]} [paths] rutas del diff (sin ignorados)
+* @returns {{ ok: boolean, errors: string[], notes: string[] }}
+*/
+function checkPayload(payload, paths = []) {
+	const errors = [...validateAgainst(REVIEW_SCHEMA, payload), ...reviewIssues(payload)];
+	const notes = [];
+	const known = (paths || []).map((p) => String(p || "").replaceAll("\\", "/")).filter(Boolean);
+	if (known.length) {
+		const blocks = Array.isArray(payload?.blocks) ? payload.blocks : [];
+		const findings = Array.isArray(payload?.findings) ? payload.findings : [];
+		const skippedPatterns = (Array.isArray(payload?.skipped) ? payload.skipped : []).map((s) => String(s?.file || "")).filter(Boolean);
+		const covers = (file) => {
+			const norm = String(file || "").replaceAll("\\", "/");
+			if (blocks.some((b) => String(b?.file || "").replaceAll("\\", "/") === norm)) return true;
+			return skippedPatterns.some((pattern) => {
+				const p = pattern.replaceAll("\\", "/");
+				return p === norm || globMatch(norm, p);
+			});
+		};
+		for (const block of blocks) {
+			const file = String(block?.file || "").replaceAll("\\", "/");
+			if (file && !known.includes(file)) errors.push(`el bloque ${block.id || file} apunta a un archivo que no está en el diff: ${file}`);
+		}
+		for (const finding of findings) {
+			const file = String(finding?.file || "").replaceAll("\\", "/");
+			if (file && !known.includes(file)) errors.push(`el hallazgo ${finding.id || finding.what || file} apunta a un archivo fuera del diff: ${file}`);
+		}
+		const missing = known.filter((file) => !covers(file));
+		if (missing.length) {
+			const shown = missing.slice(0, MISSING_LIMIT);
+			const rest = missing.length - shown.length;
+			errors.push(`quedaron ${missing.length} archivo(s) del diff sin bloque ni skipped: ${shown.join(", ")}${rest > 0 ? ` … y ${rest} más` : ""}`);
+		}
+	} else notes.push("No contrasté cobertura contra git (sin lista de paths del diff).");
+	return {
+		ok: errors.length === 0,
+		errors,
+		notes
+	};
+}
+/**
+* @param {string} filePath
+* @param {{ repo?: string, branch?: string, base?: string, cwd?: string, paths?: string[] }} [opts]
+*   `paths`: lista ya conocida (p. ej. de la sesión); si viene, no se lee el `.diff` ni se llama a git.
+*/
+function checkReportFile(filePath, opts = {}) {
+	const cwd = opts.cwd || process.cwd();
+	const abs = isAbsolute(filePath) ? filePath : resolve(cwd, filePath);
+	if (!existsSync(abs)) return {
+		ok: false,
+		file: abs,
+		errors: [`No existe el archivo: ${abs}`],
+		notes: [],
+		usage: true
+	};
+	let payload;
+	try {
+		payload = decodePayload(readFileSync(abs, "utf8"));
+	} catch (err) {
+		return {
+			ok: false,
+			file: abs,
+			errors: [err instanceof Error ? err.message : String(err)],
+			notes: []
+		};
+	}
+	const meta = payload && typeof payload === "object" ? payload.meta || {} : {};
+	const branch = String(opts.branch || meta.branch || "").trim();
+	const base = String(opts.base || meta.base || "develop").trim();
+	const repoHint = String(opts.repo || meta.repo || "").trim();
+	const repo = (repoHint && !/^(https?:\/\/|git@|ssh:\/\/)/i.test(repoHint) ? tryResolveGitRoot(repoHint) || (existsSync(repoHint) ? resolve(repoHint) : null) : null) || tryResolveGitRoot(cwd) || repoRootFromReviewFile(abs);
+	/** @type {string[]} */
+	let paths = Array.isArray(opts.paths) ? opts.paths.map(String).filter(Boolean) : [];
+	/** @type {string[]} */
+	const errors = [];
+	if (paths.length) ; else if (!branch) errors.push("Falta meta.branch (o --branch) para contrastar el diff.");
+	else if (!repo) errors.push("No encontré un repo local (meta.repo, el directorio actual, o la carpeta del JSON). Sin eso no puedo verificar cobertura.");
+	else try {
+		paths = (loadBranchDiff({
+			repo,
+			branch,
+			base,
+			filename: basename(abs)
+		}).files || []).map((f) => f.path);
+	} catch (err) {
+		errors.push(`No pude listar el diff (${err instanceof Error ? err.message : String(err)}). Revisá meta.repo, meta.branch y meta.base, o el companion .diff.`);
+	}
+	const result = checkPayload(payload, paths);
+	const allErrors = [...result.errors, ...errors];
+	return {
+		ok: allErrors.length === 0,
+		errors: allErrors,
+		notes: result.notes,
+		file: abs
+	};
+}
+/**
+* @param {string} file
+* @param {string} command
+* @param {{ ok: boolean, errors: string[], notes: string[] }} result
+*/
+function formatCheckReport(file, command, result) {
+	if (result.ok) return `OK: ${file}${result.notes?.length ? `\n${result.notes.map((n) => `Note: ${n}`).join("\n")}` : ""}\nSchema and references passed. You can stop.`;
+	const problems = (result.errors || []).map((e) => `- ${e}`).join("\n");
+	const notes = (result.notes || []).map((n) => `Note: ${n}`).join("\n");
+	const lines = [
+		`INVALID: ${file}`,
+		"",
+		"The JSON is not ready. Edit this same file until the command prints OK. Do not create a new filename.",
+		"",
+		"Problems:",
+		problems || "- (unknown)"
+	];
+	if (notes) lines.push("", notes);
+	lines.push("", "How to continue:", "- Fix every problem above in place. Keep existing meta/intent/groups/blocks/findings; only change what is wrong or missing.", "- Every diff path must appear in \"blocks\" or \"skipped\" (a skipped glob counts).", "- If a problem lists missing paths: ADD a block or a skipped entry for each exact path. Do not only bump meta.generatedAt, notes, or claim the file is already complete.", "- meta.agent and meta.model are required (product name and the exact model id you are running).", "- intent ≥40 chars; enums exactly as in the schema.", "- Human-readable strings in Spanish.", `- Re-run exactly: \`${command}\``, "- Stop only when that command prints OK.");
+	return lines.join("\n");
+}
+//#endregion
+//#region ../lib/review-meta.mjs
+/**
+* Estampa en el JSON quién generó la review. La CLI lo sabe mejor que el modelo.
+*/
+/**
+* `agentSession` = la sesión ACP que generó la review, para seguir conversando con el agente desde la web.
+* @param {string} filePath
+* @param {{ agent?: string, model?: string, agentSession?: { agentId: string, sessionId: string, outputFilename: string } }} provenance
+* @returns {boolean}
+*/
+function stampReviewProvenance(filePath, { agent, model, agentSession } = {}) {
+	const agentName = String(agent || "").trim();
+	const modelId = String(model || "").trim();
+	if (!agentName && !modelId && !agentSession) return false;
+	let payload;
+	try {
+		payload = decodePayload(readFileSync(filePath, "utf8"));
+	} catch {
+		return false;
+	}
+	if (!payload || typeof payload !== "object" || Array.isArray(payload)) return false;
+	const current = payload.meta;
+	const meta = current && typeof current === "object" && !Array.isArray(current) ? { ...current } : {};
+	if (agentName) meta.agent = agentName;
+	if (modelId) meta.model = modelId;
+	if (agentSession) meta.agentSession = { ...agentSession };
+	payload.meta = meta;
+	writeFileSync(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+	return true;
+}
+//#endregion
+//#region ../lib/prompt.mjs
+/**
+* Prompt de review para el agente (compartido CLI + UI).
+* Mantener alineado con el contrato de schema.json / validate.mjs.
+*/
+var OUTPUT_SCHEMA_BLOCK = `{
+  "meta": {
+    "source": "local|url",
+    "repo": "<absolute path or git URL>",
+    "branch": "<branch under review>",
+    "base": "develop",
+    "remoteUrl": "<origin URL; optional when source=url>",
+    "generatedAt": "<ISO-8601 datetime; optional>",
+    "agent": "<required: product name you are, e.g. Claude Code>",
+    "model": "<required: exact model id you are running>"
+  },
+  "intent": "string",
+  "groups": [
+    {
+      "id": "t1",
+      "kind": "feat|fix|refactor|perf|test|chore|docs|infra",
+      "title": "string, aim for ≤72 chars, imperative, no kind prefix",
+      "intent": "string"
+    }
+  ],
+  "blocks": [
+    {
+      "id": "b1",
+      "group": "t1",
+      "file": "relative/path.ext",
+      "lines": "L40-58",
+      "side": "new|old",
+      "start": 40,
+      "end": 58,
+      "op": "add|mod|del|rename",
+      "what": "string, aim for ≤120 chars: concrete change + effect",
+      "why": "string, aim for ≤120 chars",
+      "source": "code|commit|pr|issue|inferred"
+    }
+  ],
+  "findings": [
+    {
+      "id": "f1",
+      "class": "risk|quality",
+      "severity": "high|med|low|nit",
+      "blocking": false,
+      "kind": "bug|race|auth|security|api-break|missing-test|perf|maintainability|docs|other",
+      "file": "relative/path.ext",
+      "line": 87,
+      "block": "b1",
+      "what": "string, aim for ≤120 chars: concrete cause + observable consequence (what fails / risk / cost)",
+      "fix": "string, aim for ≤120 chars: suggested change + what the reader gains or avoids if applied"
+    }
+  ],
+  "skipped": [
+    { "file": "relative/path-or-glob", "reason": "generated|lockfile|format|vendored|binary|trivial|ignored" }
+  ],
+  "notes": ["optional short limitations"]
+}`;
+var RULES = `- Ids: themes use \`t1\`, \`t2\`, …; findings use \`f1\`, \`f2\`, …; blocks use \`b1\`, \`b2\`, …. Reference themes from blocks via \`"group": "t1"\`.
+- Coverage (hard): every path in the diff MUST appear in "blocks" and/or "skipped". Prefer a skipped glob when many files share one reason.
+- Do NOT invent files, hunks, or line ranges that are not in the diff.
+- Line anchors: "lines"/"start"/"end"/"line" MUST match the chosen "side" ("new" = post-image / right side of @@; "old" = pre-image, typically deletions). One block per coherent change span, not one per line. Point findings at that block; leave "block" empty only if cross-cutting.
+- Do NOT report: pre-existing code outside the diff; linter/formatter noise; naming/style prefs with no real consequence; intentional branch behavior; silenced lint rules; "missing docs/coverage" without a concrete broken scenario.
+- Quality findings must name a concrete cost, not a vague feeling.
+- Finding "what": state the concrete cause and the observable consequence (what fails, the risk, or the cost) — not only a symptom.
+- Finding "fix": state the suggested change and what the reader gains or avoids if they apply it.
+- Signal over volume: prefer fewer high-signal findings. Order findings by severity (high, then nit). Use "nit" sparingly.
+- "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.`;
+/** @param {{ hasDiff?: boolean }} [ctx] */
+function workflowLocal(base, branch, ctx = {}) {
+	if (ctx.hasDiff) return `Workflow:
+1. Read the three-dot diff from the path given in "Precomputed git context" below. Do not re-run \`git diff\` unless that file is missing.
+2. Read enough surrounding code (types, callers, tests) to judge behavior, not only the hunk lines.
+3. Emit the JSON file. Do not modify the repo.
+4. Validate it with the command in the output section. If it prints INVALID, follow "How to continue" and re-run until it prints OK.`;
+	return `Workflow:
+1. Resolve the merge-base of \`${base}\` and \`${branch}\`.
+2. Run exactly: \`git diff ${base}...${branch}\` (three-dot / merge-base diff). Do not use two-dot unless three-dot is impossible.
+3. Read enough surrounding code (types, callers, tests) to judge behavior, not only the hunk lines.
+4. Emit the JSON file. Do not modify the repo.
+5. Validate it with the command in the output section. If it prints INVALID, follow "How to continue" and re-run until it prints OK.`;
+}
+/** Comando que el agente debe correr (sobre `.diff-review/<nombre>`); npx por si el bin no está en PATH. */
+function validateCliCommand(filename) {
+	return `npx --yes @jpkme/diff-review validate ${outputRelPath(String(filename || "diff-rev_<branchTip>_<baseTip>.json").trim())}`;
+}
+/** Workflow sin paso de validate por CLI (sesiones ACP: valida el server). */
+function workflowLocalAcp(ctx = {}) {
+	if (ctx.hasDiff) return `Workflow:
+1. Read the three-dot diff from the path given in "Precomputed git context" below. Do not re-run \`git diff\` unless that file is missing.
+2. Read enough surrounding code (types, callers, tests) to judge behavior, not only the hunk lines.
+3. Write the JSON with your file Write/Edit tool (never shell redirection). Do not modify other repo files. The host validates when your turn ends — do not run the validate CLI.`;
+	return `Workflow:
+1. Resolve the merge-base of the base and branch named above, then run the three-dot \`git diff base...branch\`.
+2. Read enough surrounding code (types, callers, tests) to judge behavior, not only the hunk lines.
+3. Write the JSON with your file Write/Edit tool (never shell redirection). Do not modify other repo files. The host validates when your turn ends — do not run the validate CLI.`;
+}
+/**
+* @param {{ source?: string, repo?: string, branch?: string, base?: string, remoteUrl?: string }} meta
+*/
+function outputSchemaBlock(meta) {
+	const source = "local";
+	const repo = String(meta.repo || "").trim() || ("<absolute repo path>");
+	const branch = String(meta.branch || "").trim() || "<branch under review>";
+	const base = String(meta.base || "").trim() || "develop";
+	const remoteUrl = String(meta.remoteUrl || "").trim() || ("");
+	const metaLines = [
+		`    "source": ${JSON.stringify(source)},`,
+		`    "repo": ${JSON.stringify(repo)},`,
+		`    "branch": ${JSON.stringify(branch)},`,
+		`    "base": ${JSON.stringify(base)},`
+	];
+	if (remoteUrl) metaLines.push(`    "remoteUrl": ${JSON.stringify(remoteUrl)},`);
+	metaLines.push(`    "generatedAt": "<ISO-8601 datetime>",`, `    "agent": "<required: product name you are, e.g. Claude Code>",`, `    "model": "<required: exact model id you are running>"`);
+	const metaBlock = `"meta": {\n${metaLines.join("\n")}\n  }`;
+	return OUTPUT_SCHEMA_BLOCK.replace(/"meta": \{[\s\S]*?\n  \}/, metaBlock);
+}
+/**
+* Bloque de contexto git ya resuelto (diff en disco, tips, lista de archivos, ignores).
+* @param {{
+*   diffRelPath?: string | null,
+*   mergeBase?: string,
+*   branchSha?: string,
+*   baseSha?: string,
+*   files?: Array<{ path: string, changeType?: string }>,
+*   ignored?: string[],
+*   ignoreGlobs?: string[],
+* }} ctx
+*/
+function formatPrecomputedContext(ctx) {
+	const lines = ["Precomputed git context (do not rediscover):"];
+	if (ctx.mergeBase) lines.push(`- Merge-base SHA: \`${ctx.mergeBase}\``);
+	if (ctx.branchSha) lines.push(`- Branch tip SHA: \`${ctx.branchSha}\``);
+	if (ctx.baseSha) lines.push(`- Base tip SHA: \`${ctx.baseSha}\``);
+	if (ctx.diffRelPath) lines.push(`- Diff file (relative to repo root): \`${ctx.diffRelPath}\` — read this file; do not re-run \`git diff\` unless it is missing.`);
+	const files = Array.isArray(ctx.files) ? ctx.files : [];
+	if (files.length) {
+		lines.push(`- Files in the diff (${files.length}):`);
+		const limit = 200;
+		for (const f of files.slice(0, limit)) {
+			const path = String(f?.path || "").trim();
+			if (!path) continue;
+			const kind = String(f?.changeType || "").trim();
+			lines.push(kind ? `  - ${kind}: ${path}` : `  - ${path}`);
+		}
+		if (files.length > limit) lines.push(`  - … and ${files.length - limit} more`);
+	}
+	const ignored = Array.isArray(ctx.ignored) ? ctx.ignored.filter(Boolean) : [];
+	if (ignored.length) {
+		lines.push(`- Ignored paths (excluded from the file list; if you mention them use "skipped" with reason "ignored"):`);
+		for (const p of ignored.slice(0, 40)) lines.push(`  - ${p}`);
+		if (ignored.length > 40) lines.push(`  - … and ${ignored.length - 40} more`);
+	}
+	const globs = Array.isArray(ctx.ignoreGlobs) ? ctx.ignoreGlobs.filter(Boolean) : [];
+	if (globs.length) lines.push(`- Ignore globs (DEFAULT + config): ${globs.map((g) => `\`${g}\``).join(", ")}`);
+	return lines.join("\n");
+}
+/**
+* @param {{ source?: string, repo?: string, branch?: string, base?: string, remoteUrl?: string }} meta
+* @param {{
+*   outputFilename?: string,
+*   acp?: boolean,
+*   diffRelPath?: string | null,
+*   mergeBase?: string,
+*   branchSha?: string,
+*   baseSha?: string,
+*   files?: Array<{ path: string, changeType?: string }>,
+*   ignored?: string[],
+*   ignoreGlobs?: string[],
+* }} [opts]
+*/
+function buildPrompt(meta, opts = {}) {
+	const outputFilename = opts.outputFilename || makeOutputFilename();
+	const outputPath = outputRelPath(outputFilename);
+	const repo = String(meta.repo || "").trim() || ("<absolute repo path>");
+	const branch = String(meta.branch || "").trim() || "<branch under review>";
+	const base = String(meta.base || "").trim() || "develop";
+	const acp = Boolean(opts.acp);
+	const hasDiff = Boolean(String(opts.diffRelPath || "").trim());
+	const workflow = acp ? workflowLocalAcp({ hasDiff }) : workflowLocal(base, branch, { hasDiff });
+	const precomputed = formatPrecomputedContext({
+		diffRelPath: opts.diffRelPath,
+		mergeBase: opts.mergeBase,
+		branchSha: opts.branchSha,
+		baseSha: opts.baseSha,
+		files: opts.files,
+		ignored: opts.ignored,
+		ignoreGlobs: opts.ignoreGlobs
+	});
+	const hasPrecomputed = hasDiff || opts.mergeBase || opts.branchSha || opts.baseSha || opts.files && opts.files.length || opts.ignored && opts.ignored.length || opts.ignoreGlobs && opts.ignoreGlobs.length;
+	const validateSection = acp ? `When done writing \`${outputPath}\`, stop. The host validates the JSON automatically and will send you any problems — do not run \`npx … validate\` yourself.` : `After writing the file, validate it (npx so it works even if \`diff-review\` is not on PATH):
+
+\`${validateCliCommand(outputFilename)}\`
+
+- Exit 0 and a line starting with \`OK\` means the JSON is acceptable. Then tell me that \`${outputPath}\` was written.
+- Exit 1 prints \`INVALID\`, the problems, and how to continue. Fix the same file and re-run that exact command until it prints OK. Do not stop before OK.`;
+	return `You are a senior code reviewer: strict but fair.
+
+Repo: ${repo}
+Branch under review: ${branch}
+Base (merge-base): ${base}
+
+${workflow}
+${hasPrecomputed ? `\n${precomputed}\n` : ""}
+Rules:
+${RULES}
+
+Write the result to \`${outputPath}\` (relative to the repo root; use forward slashes, never \`\\\`). The \`${OUTPUT_DIR}/\` folder is already created by the host — do not \`mkdir\` it.
+- If that file already exists: **Read it first**, then Edit/overwrite (or Write after Read). Many agents reject Write with "File has not been read yet" unless you Read that exact path first.
+- If it does not exist yet: Write is fine. Do NOT use shell redirection (\`>\`, \`>>\`, \`Out-File\`, \`tee\`, etc.) — those are rejected.
+- One JSON object only: first character \`{\`, last character \`}\`.
+- No prose before/after, no markdown fences.
+- Shape (copy "meta" source/repo/branch/base/remoteUrl as given; "agent" and "model" are required):
+
+${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.
+
+${validateSection}`;
+}
+//#endregion
+//#region ../lib/review-prep.mjs
+/**
+* Precomputa contexto git para el prompt de review (diff cache + lista de archivos).
+*/
+/**
+* Cachea el three-dot diff y arma las opciones de `buildPrompt` (tips, files, ignores).
+* @param {{
+*   repo: string,
+*   branch: string,
+*   base?: string,
+*   outputFilename: string,
+*   acp?: boolean,
+* }} input
+*/
+function prepareReviewPromptOpts(input) {
+	const repo = String(input.repo || "").trim();
+	const branch = String(input.branch || "").trim();
+	const base = String(input.base || "develop").trim() || "develop";
+	const outputFilename = String(input.outputFilename || "").trim();
+	if (!repo || !branch || !outputFilename) throw new Error("prepareReviewPromptOpts requiere repo, branch y outputFilename.");
+	ensureReviewDir(repo);
+	writeDiffCache(repo, outputFilename, {
+		branch,
+		base
+	});
+	const cached = readDiffCache(repo, outputFilename);
+	let extracted;
+	try {
+		extracted = extractBranchDiff({
+			repo,
+			branch,
+			base,
+			...cached ? { cachedDiff: cached } : {}
+		});
+	} catch {
+		extracted = extractBranchDiff({
+			repo,
+			branch,
+			base
+		});
+	}
+	const config = loadReviewConfig(repo);
+	const diffRelPath = cached ? outputRelPath(outputFilename).replace(/\.json$/i, ".diff") : null;
+	return {
+		outputFilename,
+		acp: Boolean(input.acp),
+		diffRelPath,
+		mergeBase: extracted.mergeBase || void 0,
+		branchSha: extracted.branchSha || void 0,
+		baseSha: extracted.baseSha || void 0,
+		files: (extracted.files || []).map((f) => ({
+			path: f.path,
+			changeType: f.changeType
+		})),
+		ignored: extracted.context?.ignored || [],
+		ignoreGlobs: config.ignore
+	};
+}
+//#endregion
+//#region src/lib/report/agent-events.ts
+/**
+* Aplica un evento a la lista: un `text` con el mismo `seq` que el último es la continuación de ese chunk.
+*/
+function applyEvent(events, event) {
+	const last = events[events.length - 1];
+	if (last && last.seq === event.seq && last.type === "text" && event.type === "text") return [...events.slice(0, -1), {
+		...last,
+		text: last.text + event.text
+	}];
+	if (event.type === "tool") {
+		const i = events.findIndex((e) => e.type === "tool" && e.id === event.id);
+		if (i >= 0) {
+			const prev = events[i];
+			const merged = {
+				...prev,
+				title: event.title || prev.title,
+				kind: event.kind || prev.kind,
+				status: event.status || prev.status
+			};
+			return [
+				...events.slice(0, i),
+				merged,
+				...events.slice(i + 1)
+			];
+		}
+	}
+	if (event.type === "permission") {
+		const i = events.findIndex((e) => e.type === "permission" && e.requestId === event.requestId);
+		if (i >= 0) return [
+			...events.slice(0, i),
+			event,
+			...events.slice(i + 1)
+		];
+	}
+	return [...events, event];
+}
+//#endregion
+//#region src/lib/server/agent-sessions.ts
+/**
+* Sesiones con agentes por ACP, del lado del server: el server es dueño del proceso del agente y la web lo sigue
+* por SSE (`/api/agent/[id]/events`). Una sesión genera la review y después queda viva para preguntas y cambios.
+*
+* Los procesos viven en memoria; lo que tiene que sobrevivir va a `.diff-review/` del repo: el JSON, el diff y la
+* sesión del agente (`<nombre>.session.json`). Para chatear sobre un reporte se retoma esa sesión
+* (`session/load`); si no se puede (se borró, otro agente, otra máquina) se abre una nueva y el primer mensaje le
+* pasa el contexto: repo, branch, base y dónde están el diff y el JSON.
+*/
+/** Para que el agente no gaste turnos en comandos que la política va a rechazar. */
+var TOOL_RULES = "Tool rules for this session: read files with your file tools (read/search/glob). For the review JSON path: use forward slashes (e.g. .diff-review/foo.json). If that file already exists, Read it first, then Edit/Write — Write fails with \"File has not been read yet\" unless you Read that exact path. Never shell redirection (>, >>, Out-File, tee). The .diff-review/ folder already exists — do not mkdir it. In the terminal only read-only commands run (git diff/log/show/blame/…, cat, head, tail, grep, rg, find, ls, wc, sed -n). No redirections to files, no command substitution, no installs, no network. Anything else is rejected automatically: do not retry the same rejected command; use the file tool or another read-only way.";
+/**
+* En estas sesiones valida el server al terminar cada turno (y le devuelve los errores al agente): correr el
+* validate por npx es lento y puede resolver otra versión del paquete.
+*/
+var SERVER_VALIDATES = "Note: in this session diff-review validates the JSON automatically when your turn ends and sends you any problems. Do not run the validate command yourself.";
+/** Sin actividad por este tiempo se cierra el proceso del agente (se retoma con `session/load`). */
+var IDLE_CLOSE_MS = 1800 * 1e3;
+var MAX_EVENTS = 4e3;
+/** Si el usuario no responde un permiso pendiente, se rechaza para no colgar el turno. */
+var PERMISSION_TIMEOUT_MS = 120 * 1e3;
+var sessions = /* @__PURE__ */ new Map();
+process.once("exit", () => {
+	for (const entry of sessions.values()) entry.acp?.close();
+});
+function listAcpAgents() {
+	return detectAgents().filter(supportsAcp).map((a) => ({
+		id: a.def.id,
+		label: a.def.label,
+		path: a.path,
+		models: modelChoices(a.def).options
+	}));
+}
+var modelsCache = /* @__PURE__ */ new Map();
+/**
+* Modelos que ofrece el agente por ACP (abre una sesión de prueba; tarda unos segundos).
+* Solo cachea listas no vacías. `force` invalida la caché. Vacío o error → se puede reintentar.
+*/
+function agentModels(agentId, cwd, opts) {
+	if (opts?.force) modelsCache.delete(agentId);
+	let hit = modelsCache.get(agentId);
+	if (!hit) {
+		const agent = findAgent(agentId);
+		hit = listAcpModelsCached(agent, {
+			cwd,
+			force: Boolean(opts?.force)
+		}).then((result) => {
+			if (!result.models.length) modelsCache.delete(agentId);
+			const { fromCache: _fromCache, ...rest } = result;
+			return rest;
+		}).catch((err) => {
+			modelsCache.delete(agentId);
+			const raw = err instanceof Error ? err.message : String(err);
+			const auth = authFailureMessage(agentId, agent.def.label, raw);
+			throw new Error(auth || raw);
+		});
+		modelsCache.set(agentId, hit);
+	}
+	return hit;
+}
+function findAgent(agentId) {
+	const agent = detectAgents().find((a) => a.def.id === agentId);
+	if (!agent) throw new Error(`No encontré el agente "${agentId}" instalado.`);
+	if (!supportsAcp(agent)) throw new Error(`${agent.def.label} no tiene modo ACP.`);
+	return agent;
+}
+function info(entry) {
+	const { id, agentId, agentLabel, model, repo, branch, base, outputFilename, acpSessionId, status, busy, statusMessage, sessionAllowDenied } = entry;
+	return {
+		id,
+		agentId,
+		agentLabel,
+		model,
+		repo,
+		branch,
+		base,
+		outputFilename,
+		acpSessionId,
+		status,
+		busy,
+		sessionTrust: Boolean(sessionAllowDenied),
+		...statusMessage ? { statusMessage } : {}
+	};
+}
+function authFailureMessage(agentId, agentLabel, detail) {
+	return authFailureMessage$1(agentId, agentLabel, detail);
+}
+/** Abre una terminal con el login del agente (Claude `/login`, `gh auth login`, …). */
+function openAgentLogin(agentId) {
+	return openLoginTerminal(String(agentId || ""));
+}
+/** Escribe seed (JSON + .diff) en `.diff-review/` para que el agente los lea. */
+function materializeSeed(entry) {
+	const seed = entry.seed;
+	if (!seed) return;
+	try {
+		ensureReviewDir(entry.repo);
+		const paths = companionPaths(entry.repo, entry.outputFilename);
+		if (seed.payload !== void 0) writeFileSync(paths.json, `${JSON.stringify(seed.payload, null, 2)}\n`);
+		if (typeof seed.diff === "string" && seed.diff.length) writeDiffText(entry.repo, entry.outputFilename, seed.diff);
+		else writeDiffCache(entry.repo, entry.outputFilename, {
+			branch: entry.branch,
+			base: entry.base
+		});
+	} catch {}
+}
+/** Prefijo del primer mensaje cuando la sesión ACP es nueva. */
+function contextPreamble(entry) {
+	materializeSeed(entry);
+	const paths = companionPaths(entry.repo, entry.outputFilename);
+	const jsonRel = outputRelPath(entry.outputFilename);
+	const diffRel = `${outputRelPath(entry.outputFilename).replace(/\.json$/i, "")}.diff`;
+	const hasJson = existsSync(paths.json);
+	const hasDiff = existsSync(paths.diff);
+	return [
+		"Context for this chat (new agent session — read these files before answering):",
+		`- Repo: ${entry.repo}`,
+		`- Branch under review: ${entry.branch}`,
+		`- Base: ${entry.base}`,
+		hasJson ? `- Review JSON (relative to repo root): \`${jsonRel}\` — read this file.` : `- Review JSON: not available on disk (no seed/payload was provided). Say so if you need it.`,
+		hasDiff ? `- Diff (relative to repo root): \`${diffRel}\` — read this file.` : `- Diff file: not available on disk (no seed/diff and git cache failed). Say so if you need it.`,
+		"",
+		"User message:"
+	].join("\n");
+}
+function permissionReasonLabel(allow, scope, deniedReason) {
+	if (!allow) return deniedReason;
+	if (scope === "always") return "permitido siempre";
+	if (scope === "session") return "permitido en esta sesión";
+	return "permitido una vez";
+}
+function askUserPermission(entry, toolCall, decision) {
+	if (entry.sessionAllowDenied) return Promise.resolve({
+		allow: true,
+		always: false
+	});
+	const requestId = crypto.randomUUID();
+	const kind = toolCall.kind || "";
+	const command = toolCallCommand(toolCall);
+	const title = toolCallLabel(toolCall, command) || (command ? "" : toolCall.title || kind || "herramienta");
+	const reason = humanizePolicyReason(decision.reason);
+	const base = {
+		requestId,
+		title,
+		kind,
+		reason,
+		command: command || void 0
+	};
+	emit(entry, {
+		type: "permission",
+		...base,
+		allow: false,
+		pending: true
+	});
+	return new Promise((resolve) => {
+		const timer = setTimeout(() => {
+			entry.pendingPermissions.delete(requestId);
+			emit(entry, {
+				type: "permission",
+				...base,
+				reason: "tiempo agotado",
+				allow: false,
+				pending: false
+			});
+			resolve({ allow: false });
+		}, PERMISSION_TIMEOUT_MS);
+		timer.unref?.();
+		entry.pendingPermissions.set(requestId, {
+			resolve: (allow, opts) => {
+				clearTimeout(timer);
+				entry.pendingPermissions.delete(requestId);
+				const scope = opts?.scope ?? "once";
+				if (allow && (scope === "session" || scope === "always")) entry.sessionAllowDenied = true;
+				emit(entry, {
+					type: "permission",
+					...base,
+					reason: permissionReasonLabel(allow, scope, reason),
+					allow,
+					pending: false,
+					quiet: opts?.quiet
+				});
+				resolve({
+					allow,
+					always: allow && scope === "always"
+				});
+			},
+			timer
+		});
+	});
+}
+function sessionInfo(id) {
+	const entry = sessions.get(id);
+	return entry ? info(entry) : null;
+}
+/**
+* Con la CLI mirando (`DIFF_REVIEW_MIRROR=1`), solo fallos duros a la terminal.
+* El progreso (tools, permisos, mensajes) vive en la web.
+*/
+function mirror(_entry, event) {
+	if (process.env.DIFF_REVIEW_MIRROR !== "1") return;
+	if (event.type === "status" && event.status === "error") console.log(`✗ ${event.message || "error del agente"}`);
+	else if (event.type === "review" && event.ok) console.log(`✓ JSON válido: ${event.filename}`);
+}
+function emit(entry, event) {
+	let seq;
+	if (event.type === "text" && entry.textSeq?.kind === event.kind) seq = entry.textSeq.seq;
+	else {
+		seq = ++entry.seq;
+		entry.textSeq = event.type === "text" ? {
+			kind: event.kind,
+			seq
+		} : null;
+	}
+	const full = {
+		...event,
+		seq
+	};
+	mirror(entry, event);
+	entry.events = applyEvent(entry.events, full);
+	if (entry.events.length > MAX_EVENTS) entry.events = entry.events.slice(-4e3);
+	for (const listener of entry.listeners) listener(full);
+}
+function setStatus(entry, status, message) {
+	entry.status = status;
+	if (status === "error") entry.statusMessage = message || entry.statusMessage || "Error del agente.";
+	else if (message !== void 0) delete entry.statusMessage;
+	emit(entry, {
+		type: "status",
+		status,
+		...message || status === "error" ? { message: message || entry.statusMessage } : {}
+	});
+}
+/** SessionUpdate de ACP → evento de la web (lo que no se muestra se descarta). */
+function toEvent(update) {
+	switch (update.sessionUpdate) {
+		case "agent_message_chunk":
+		case "agent_thought_chunk": {
+			const content = update.content;
+			if (content.type !== "text" || !content.text) return null;
+			return {
+				type: "text",
+				kind: update.sessionUpdate === "agent_message_chunk" ? "message" : "thought",
+				text: content.text
+			};
+		}
+		case "tool_call":
+		case "tool_call_update": return {
+			type: "tool",
+			id: update.toolCallId,
+			title: update.title ?? "",
+			kind: update.kind ?? "",
+			status: update.status ?? ""
+		};
+		case "plan": return {
+			type: "plan",
+			entries: update.entries.map((e) => ({
+				content: e.content,
+				status: e.status
+			}))
+		};
+		default: return null;
+	}
+}
+function scheduleIdleClose(entry) {
+	if (entry.idleTimer) clearTimeout(entry.idleTimer);
+	entry.idleTimer = setTimeout(() => {
+		if (entry.busy || !entry.acp) return;
+		entry.acp.close();
+		entry.acp = null;
+	}, IDLE_CLOSE_MS);
+	entry.idleTimer.unref?.();
+}
+/** Aplica el modelo pedido a la sesión ACP viva (o no-op si ya está). */
+async function applyAcpModel(entry, acp, model) {
+	const wanted = String(model || "").trim();
+	if (!wanted) return acp;
+	const result = await acp.setModel(wanted);
+	if (result.currentModel && !result.currentModel.startsWith("default")) entry.model = result.currentModel;
+	if (result.warning) emit(entry, {
+		type: "status",
+		status: entry.status,
+		message: result.warning
+	});
+	return acp;
+}
+/** Proceso del agente vivo para esta entrada: lo lanza, o lo relanza retomando la sesión. */
+async function ensureAcp(entry, model) {
+	if (entry.acp) return applyAcpModel(entry, entry.acp, model);
+	if (entry.starting) return applyAcpModel(entry, await entry.starting, model);
+	entry.starting = startAcpSession(entry.agent, {
+		cwd: entry.repo,
+		model,
+		resumeSessionId: entry.acpSessionId || void 0,
+		decide: (toolCall) => decidePermission(toolCall, {
+			repo: entry.repo,
+			outputFilename: entry.outputFilename,
+			mode: entry.mode
+		}),
+		onUpdate: (update) => {
+			if (!entry.acp && entry.acpSessionId) return;
+			const event = toEvent(update);
+			if (event) emit(entry, event);
+		},
+		onDeniedPermission: (toolCall, decision) => askUserPermission(entry, toolCall, decision),
+		onPermission: (toolCall, decision) => {
+			if (decision.allow) return;
+			entry.rejections.push(`${toolCall.title || toolCall.kind || "herramienta"} (${decision.reason})`);
+		},
+		onExit: ({ code, stderr }) => {
+			const wasBusy = entry.busy;
+			entry.acp = null;
+			if (wasBusy) {
+				entry.busy = false;
+				const auth = authFailureMessage(entry.agentId, entry.agentLabel, stderr);
+				if (auth) {
+					setStatus(entry, "error", auth);
+					return;
+				}
+				const raw = stderr.trim() || `código ${code ?? "?"}`;
+				const authFromCode = authFailureMessage(entry.agentId, entry.agentLabel, raw);
+				if (authFromCode) {
+					setStatus(entry, "error", authFromCode);
+					return;
+				}
+				const tail = stderr.trim().split(/\r?\n/).slice(-3).join(" · ");
+				setStatus(entry, "error", `${entry.agentLabel} terminó (código ${code ?? "?"}). ${tail}`.trim());
+			}
+		}
+	}).then((acp) => {
+		const wanted = entry.acpSessionId;
+		entry.acp = acp;
+		entry.acpSessionId = acp.sessionId;
+		if (wanted && !acp.resumed) {
+			entry.needsContext = true;
+			emit(entry, {
+				type: "status",
+				status: entry.status,
+				message: "No pude retomar la sesión anterior del agente: abro una nueva y le paso el contexto de la review."
+			});
+		}
+		try {
+			writeSessionRef(entry.repo, entry.outputFilename, {
+				agentId: entry.agentId,
+				sessionId: acp.sessionId,
+				...entry.model ? { model: entry.model } : {}
+			});
+		} catch {}
+		if (acp.currentModel && !acp.currentModel.startsWith("default")) entry.model = acp.currentModel;
+		if (acp.modelWarning) emit(entry, {
+			type: "status",
+			status: entry.status,
+			message: acp.modelWarning
+		});
+		return acp;
+	}).finally(() => {
+		entry.starting = null;
+	});
+	return applyAcpModel(entry, await entry.starting, model);
+}
+function mtime(path) {
+	try {
+		return statSync(path).mtimeMs;
+	} catch {
+		return 0;
+	}
+}
+/** Cuántas veces el server le pide solo al agente corregir/escribir el JSON antes de cortar con Reintentar. */
+var OUTPUT_AUTO_RETRIES = 2;
+/**
+* Después de un turno que podía escribir el JSON: validarlo, estamparle la sesión y, si quedó mal, pedirle al
+* agente que lo corrija (hasta `OUTPUT_AUTO_RETRIES` veces).
+*/
+function checkEntryReport(entry) {
+	const path = companionPaths(entry.repo, entry.outputFilename).json;
+	if (!existsSync(path)) return null;
+	return {
+		path,
+		result: checkReportFile(path, {
+			repo: entry.repo,
+			branch: entry.branch,
+			base: entry.base,
+			...entry.diffPaths?.length ? { paths: entry.diffPaths } : {}
+		})
+	};
+}
+/** Prompt cuando el JSON existe pero no pasa validación (auto-fix o Reintentar). */
+function invalidJsonFixPrompt(entry, path, result) {
+	return `${formatCheckReport(path, validateCliCommand(entry.outputFilename), result)}
+
+Critical: do NOT only bump meta.generatedAt or rewrite notes. Edit \`${outputRelPath(entry.outputFilename).replace(/\\/g, "/")}\` so every problem above is fixed (add blocks or skipped for each missing path). Do not claim success until coverage is complete.
+
+${TOOL_RULES}
+
+${SERVER_VALIDATES}`;
+}
+function noWriteFollowUpPrompt(entry) {
+	const rel = outputRelPath(entry.outputFilename);
+	const rejected = entry.rejections.length ? `These commands were rejected by diff-review's policy and did not run:\n${entry.rejections.slice(-5).map((r) => `- ${r}`).join("\n")}\n\n` : "";
+	const posixRel = rel.replace(/\\/g, "/");
+	const existing = checkEntryReport(entry);
+	return `${rejected}Your turn ended without writing \`${posixRel}\` in this turn (mtime must change now). The user did not stop you.
+${existing && !existing.result.ok ? `\nThe file on disk is also INVALID — fix these when you Write/Edit (do not only bump generatedAt):\n${(existing.result.errors || []).map((e) => `- ${e}`).join("\n")}\n` : ""}
+Do this now:
+1. Read \`${posixRel}\` if it exists (required before Write/Edit on an existing file).
+2. Edit or Write the full review JSON to that same path (forward slashes only).
+Do NOT mkdir, and do NOT use shell redirection. Do not claim success just because an older file is present — overwrite it.
+
+${TOOL_RULES}
+
+${SERVER_VALIDATES}`;
+}
+async function checkOutput(entry, since, retriesLeft) {
+	const path = companionPaths(entry.repo, entry.outputFilename).json;
+	if (!(existsSync(path) && mtime(path) >= since)) {
+		if (retriesLeft > 0) return checkOutput(entry, await followUp(entry, noWriteFollowUpPrompt(entry), entry.rejections.length ? "Seguí: hubo comandos rechazados; escribí el JSON con la tool de archivos." : "Seguí: el JSON no se escribió en este turno."), retriesLeft - 1);
+		if (entry.mode === "review") emit(entry, {
+			type: "review",
+			ok: false,
+			filename: entry.outputFilename,
+			errors: [`${entry.agentLabel} terminó sin escribir ${entry.outputFilename}.`],
+			final: true
+		});
+		return;
+	}
+	const result = checkReportFile(path, {
+		repo: entry.repo,
+		branch: entry.branch,
+		base: entry.base,
+		...entry.diffPaths?.length ? { paths: entry.diffPaths } : {}
+	});
+	if (result.ok) {
+		stampReviewProvenance(path, {
+			agent: entry.agentLabel,
+			model: entry.model,
+			agentSession: {
+				agentId: entry.agentId,
+				sessionId: entry.acpSessionId,
+				outputFilename: entry.outputFilename
+			}
+		});
+		emit(entry, {
+			type: "review",
+			ok: true,
+			filename: entry.outputFilename,
+			errors: [],
+			final: true
+		});
+		return;
+	}
+	const canRetry = retriesLeft > 0;
+	emit(entry, {
+		type: "review",
+		ok: false,
+		filename: entry.outputFilename,
+		errors: result.errors,
+		final: !canRetry
+	});
+	if (!canRetry) return;
+	await checkOutput(entry, await followUp(entry, invalidJsonFixPrompt(entry, path, result), "Corregí los errores de validación del JSON."), retriesLeft - 1);
+}
+/** Turno extra que pide el server (corregir el JSON, seguir después de un rechazo). Devuelve cuándo empezó. */
+async function followUp(entry, prompt, shown) {
+	emit(entry, {
+		type: "user",
+		text: shown,
+		mode: "fix"
+	});
+	const acp = await ensureAcp(entry);
+	const started = Date.now();
+	entry.rejections = [];
+	const { stopReason } = await acp.prompt(prompt);
+	emit(entry, {
+		type: "turn",
+		stopReason
+	});
+	return started;
+}
+async function runTurn(entry, text, mode, opts) {
+	if (entry.busy) throw new Error("El agente todavía está trabajando en el pedido anterior.");
+	entry.busy = true;
+	entry.mode = mode;
+	if (entry.idleTimer) clearTimeout(entry.idleTimer);
+	emit(entry, {
+		type: "user",
+		text: opts.shown,
+		mode: mode === "review" ? "review" : mode
+	});
+	try {
+		if (!entry.acp) setStatus(entry, "starting", `Lanzando ${entry.agentLabel}…`);
+		const acp = await ensureAcp(entry, opts.model);
+		setStatus(entry, "working", "El agente está revisando…");
+		const since = Date.now();
+		entry.rejections = [];
+		const { stopReason } = await acp.prompt(text);
+		emit(entry, {
+			type: "turn",
+			stopReason
+		});
+		if (mode !== "ask" && stopReason !== "cancelled") await checkOutput(entry, since, OUTPUT_AUTO_RETRIES);
+		entry.busy = false;
+		setStatus(entry, "idle");
+	} catch (err) {
+		entry.busy = false;
+		const raw = err instanceof Error ? err.message : String(err);
+		setStatus(entry, "error", authFailureMessage(entry.agentId, entry.agentLabel, raw) || raw);
+	} finally {
+		scheduleIdleClose(entry);
+	}
+}
+function newEntry(agent, fields) {
+	const acpSessionId = fields.acpSessionId ?? "";
+	const entry = {
+		id: fields.id || crypto.randomUUID(),
+		agentId: agent.def.id,
+		agentLabel: agent.def.label,
+		model: fields.model,
+		repo: fields.repo,
+		branch: fields.branch,
+		base: fields.base,
+		outputFilename: fields.outputFilename,
+		acpSessionId,
+		status: "idle",
+		busy: false,
+		agent,
+		acp: null,
+		starting: null,
+		mode: "ask",
+		events: [],
+		seq: 0,
+		textSeq: null,
+		listeners: /* @__PURE__ */ new Set(),
+		idleTimer: null,
+		rejections: [],
+		needsContext: false,
+		seed: null,
+		diffPaths: null,
+		pendingPermissions: /* @__PURE__ */ new Map(),
+		sessionAllowDenied: false,
+		cancelled: false
+	};
+	sessions.set(entry.id, entry);
+	return entry;
+}
+/** Lanza la review con el agente elegido. Devuelve el id de la sesión enseguida; el resto llega por SSE. */
+function startReview(input) {
+	const entry = newEntry(findAgent(input.agentId), {
+		...input,
+		model: input.model || ""
+	});
+	emit(entry, {
+		type: "phase",
+		phase: "diff",
+		detail: "Calculando el diff…"
+	});
+	setStatus(entry, "starting", "Calculando el diff…");
+	continueReviewAfterDiff(entry, input);
+	return info(entry);
+}
+async function continueReviewAfterDiff(entry, input) {
+	await new Promise((resolve) => setImmediate(resolve));
+	if (!sessions.has(entry.id) || entry.cancelled) return;
+	let promptOpts = {
+		outputFilename: input.outputFilename,
+		acp: true,
+		diffRelPath: null,
+		files: [],
+		ignored: [],
+		ignoreGlobs: []
+	};
+	try {
+		promptOpts = prepareReviewPromptOpts({
+			repo: input.repo,
+			branch: input.branch,
+			base: input.base,
+			outputFilename: input.outputFilename,
+			acp: true
+		});
+		if (entry.cancelled || !sessions.has(entry.id)) return;
+		entry.diffPaths = (promptOpts.files || []).map((f) => f.path);
+		const n = entry.diffPaths.length;
+		const detail = n > 0 ? `Diff listo · ${n} archivo${n === 1 ? "" : "s"}. Pasando el contexto al agente…` : "Diff listo. Pasando el contexto al agente…";
+		emit(entry, {
+			type: "phase",
+			phase: "diff",
+			detail
+		});
+		setStatus(entry, "starting", detail);
+	} catch (err) {
+		if (entry.cancelled || !sessions.has(entry.id)) return;
+		const msg = `No pude precomputar el diff (${err instanceof Error ? err.message : String(err)}); el agente lo resolverá.`;
+		emit(entry, {
+			type: "phase",
+			phase: "diff",
+			detail: msg
+		});
+		emit(entry, {
+			type: "status",
+			status: entry.status,
+			message: msg
+		});
+	}
+	if (!sessions.has(entry.id) || entry.cancelled) return;
+	emit(entry, {
+		type: "phase",
+		phase: "agent",
+		detail: "El agente está revisando el branch…"
+	});
+	runTurn(entry, `${buildPrompt({
+		repo: input.repo,
+		branch: input.branch,
+		base: input.base,
+		remoteUrl: getRemoteUrl(input.repo) || void 0
+	}, promptOpts)}\n\n${TOOL_RULES}\n\n${SERVER_VALIDATES}`, "review", {
+		model: input.model,
+		shown: `Review de ${input.branch} contra ${input.base}`
+	});
+}
+/**
+* Sesión para chatear sobre un reporte: la que sigue viva en este server, o una nueva que retoma la del agente.
+* `sessionId` vacío = sesión brand-new (`session/new`) con `needsContext` desde el inicio.
+* Opcional `seed` (JSON + diff del reporte abierto) para materializarlos en `.diff-review/` antes del primer turno.
+*/
+async function openChat(input) {
+	const sessionId = String(input.sessionId || "").trim();
+	if (sessionId) {
+		for (const entry of sessions.values()) if (entry.acpSessionId === sessionId && entry.repo === input.repo) {
+			if (input.seed) entry.seed = input.seed;
+			return info(entry);
+		}
+	}
+	const entry = newEntry(findAgent(input.agentId), {
+		...input,
+		model: input.model || "",
+		acpSessionId: sessionId
+	});
+	if (input.seed) entry.seed = input.seed;
+	if (!sessionId) entry.needsContext = true;
+	try {
+		if (!entry.acp) setStatus(entry, "starting", `Lanzando ${entry.agentLabel}…`);
+		await ensureAcp(entry, input.model);
+		if (entry.status === "starting") setStatus(entry, "idle");
+	} catch (err) {
+		const raw = err instanceof Error ? err.message : String(err);
+		setStatus(entry, "error", authFailureMessage(entry.agentId, entry.agentLabel, raw) || raw);
+	}
+	return info(entry);
+}
+function sendMessage(id, text, mode, opts) {
+	const entry = sessions.get(id);
+	if (!entry) throw new Error("La sesión del agente ya no existe. Recargá la página.");
+	const body = text.trim();
+	if (!body) throw new Error("El mensaje está vacío.");
+	if (entry.busy) throw new Error("El agente todavía está trabajando en el pedido anterior.");
+	let agentText = body;
+	if (entry.needsContext) {
+		agentText = `${contextPreamble(entry)}\n${body}`;
+		entry.needsContext = false;
+		entry.seed = null;
+	}
+	runTurn(entry, mode === "edit" ? `${agentText}\n\nApply this by editing ${entry.outputFilename} in place (keep everything else as is). Reply briefly in Spanish with what you changed.\n\n${SERVER_VALIDATES}` : `${agentText}\n\nAnswer in Spanish. This is a question about the review: do not modify any file.`, mode, {
+		shown: body,
+		model: String(opts?.model || "").trim() || void 0
+	});
+	return info(entry);
+}
+/**
+* Reintento manual tras un turno de review que no dejó el JSON válido (p. ej. redirect bloqueado o JSON viejo).
+* Misma sesión ACP; no recalcula el diff.
+* Si el JSON ya existe e inválido, reenvía los errores concretos (cobertura faltante, etc.) — no un “escribí de nuevo” genérico.
+*/
+function retryReview(id) {
+	const entry = sessions.get(String(id || ""));
+	if (!entry) throw new Error("La sesión del agente ya no existe. Recargá la página.");
+	if (entry.busy) throw new Error("El agente todavía está trabajando en el pedido anterior.");
+	if (entry.status === "error") throw new Error(entry.statusMessage || "La sesión está en error; iniciá una nueva review.");
+	const posixRel = outputRelPath(entry.outputFilename).replace(/\\/g, "/");
+	const existing = checkEntryReport(entry);
+	runTurn(entry, existing && !existing.result.ok ? invalidJsonFixPrompt(entry, existing.path, existing.result) : `Continue the code review. For \`${posixRel}\`: Read it first if it exists, then Edit/Write the full JSON (forward slashes only). Do not mkdir. Never use shell redirection.
+
+${TOOL_RULES}
+
+${SERVER_VALIDATES}`, "review", { shown: existing && !existing.result.ok ? "Reintentar: corregir el JSON inválido" : "Reintentar: escribir el JSON de la review" });
+	return info(entry);
+}
+/**
+* Respuesta del usuario a permiso(s) pendiente(s).
+* `scope`: once (default) | session (no volver a preguntar en esta sesión) | always (ACP allow_always).
+* `allowAll` / `requestIds` resuelven en lote (misma scope para todos).
+*/
+function respondPermission(input) {
+	const entry = sessions.get(String(input.id || ""));
+	if (!entry) throw new Error("La sesión del agente ya no existe. Recargá la página.");
+	const allow = Boolean(input.allow);
+	const scope = input.scope === "session" || input.scope === "always" ? input.scope : "once";
+	if (allow && (scope === "session" || scope === "always")) entry.sessionAllowDenied = true;
+	let ids;
+	if (input.allowAll) ids = [...entry.pendingPermissions.keys()];
+	else if (Array.isArray(input.requestIds) && input.requestIds.length) ids = input.requestIds.map((id) => String(id || "")).filter(Boolean);
+	else {
+		const one = String(input.requestId || "");
+		ids = one ? [one] : [];
+	}
+	if (!ids.length) throw new Error("No hay pedidos de permiso pendientes.");
+	const batch = ids.length > 1 || Boolean(input.allowAll);
+	let resolved = 0;
+	for (const requestId of ids) {
+		const pending = entry.pendingPermissions.get(requestId);
+		if (!pending) {
+			if (!batch) throw new Error("Ese pedido de permiso ya no está pendiente.");
+			continue;
+		}
+		pending.resolve(allow, {
+			quiet: batch,
+			scope
+		});
+		resolved += 1;
+	}
+	if (!resolved) throw new Error("Ese pedido de permiso ya no está pendiente.");
+	if (batch) emit(entry, {
+		type: "permission_summary",
+		allow,
+		count: resolved
+	});
+	return info(entry);
+}
+/**
+* Activa/desactiva “confiar en esta sesión” (no pedir confirmación cuando la política niega).
+* Al activar, aprueba los pedidos pendientes actuales.
+*/
+function setPermissionTrust(id, enabled) {
+	const entry = sessions.get(String(id || ""));
+	if (!entry) throw new Error("La sesión del agente ya no existe. Recargá la página.");
+	entry.sessionAllowDenied = Boolean(enabled);
+	if (enabled) {
+		const ids = [...entry.pendingPermissions.keys()];
+		let resolved = 0;
+		for (const requestId of ids) {
+			const pending = entry.pendingPermissions.get(requestId);
+			if (!pending) continue;
+			pending.resolve(true, {
+				quiet: ids.length > 1,
+				scope: "session"
+			});
+			resolved += 1;
+		}
+		if (resolved > 1) emit(entry, {
+			type: "permission_summary",
+			allow: true,
+			count: resolved
+		});
+		emit(entry, {
+			type: "status",
+			status: entry.status,
+			message: "Confianza de sesión: no se pedirá confirmación de permisos."
+		});
+	} else emit(entry, {
+		type: "status",
+		status: entry.status,
+		message: "Confianza de sesión desactivada: se vuelve a pedir confirmación."
+	});
+	return info(entry);
+}
+async function cancelTurn(id) {
+	const entry = sessions.get(id);
+	if (!entry) return;
+	entry.cancelled = true;
+	if (entry.acp && entry.busy) {
+		await entry.acp.cancel();
+		return;
+	}
+	entry.busy = false;
+	setStatus(entry, "error", "Cancelado.");
+}
+function subscribe(id, listener) {
+	const entry = sessions.get(id);
+	if (!entry) return null;
+	listener({ type: "reset" });
+	for (const event of entry.events) listener(event);
+	entry.listeners.add(listener);
+	return () => entry.listeners.delete(listener);
+}
+/**
+* Review que pidió la CLI al lanzar el server (`DIFF_REVIEW_AGENT_RUN`, JSON). Se arranca una sola vez, al iniciar,
+* así corre aunque no se abra el navegador.
+*/
+function startPendingAgentRun() {
+	const raw = String(process.env.DIFF_REVIEW_AGENT_RUN || "").trim();
+	if (!raw) return;
+	delete process.env.DIFF_REVIEW_AGENT_RUN;
+	try {
+		startReview(JSON.parse(raw));
+	} catch (err) {
+		console.error("[diff-review agent] no pude lanzar la review pedida por la CLI:", err instanceof Error ? err.message : err);
+	}
+}
+
+export { sendMessage as a, setPermissionTrust as b, cancelTurn as c, retryReview as d, openAgentLogin as e, listAcpAgents as f, agentModels as g, sessionInfo as h, subscribe as i, startPendingAgentRun as j, loginCommand as l, openChat as o, respondPermission as r, startReview as s };
+//# sourceMappingURL=agent-sessions-kcUaLhK5.js.map