@jpkme/diff-review 0.1.16 → 0.1.18

package/README.md

@@ -47,30 +47,38 @@ diff-review --agent
 
 Al enviarlo a un agente, en vez de copiar el prompt pregunta el modelo (con `--agent`, primero el agente):
 
-1. **Agente**: los instalados que encuentra (Claude Code, Codex, Cursor CLI, GitHub Copilot CLI, Gemini CLI). Si ya lo elegiste en la lista anterior, este paso no se repite. Se buscan por nombre en el `PATH` y en algunas rutas fijas: en Windows, el Claude Code que trae la app de
+1. **Agente**: los instalados que encuentra (Claude Code, Cursor CLI, GitHub Copilot CLI). Si ya lo elegiste en la lista anterior, este paso no se repite. Se buscan por nombre en el `PATH` y en algunas rutas fijas: en Windows, el Claude Code que trae la app de
    escritorio (`%APPDATA%\Claude\claude-code\<versión>\…\claude.exe`) y `%LOCALAPPDATA%\cursor-agent\cursor-agent.cmd`;
    en Linux/macOS, `~/.local/bin/claude`, `~/.claude/local/claude` y `~/.local/bin/cursor-agent`.
 2. **Modelo**: arranca en el default del agente (el configurado en `~/.claude/settings.json` /
-   `ANTHROPIC_MODEL`, `~/.codex/config.toml`, `~/.cursor/cli-config.json`, `~/.copilot/settings.json` o
-   `~/.gemini/settings.json`; si no hay, no se pasa `--model`). También lista los conocidos (para Claude, los
-   alias `opus` / `sonnet` / `haiku`; para Copilot, `auto`) y "Otro…" para escribir un id.
-
-El prompt viaja por stdin y la salida del agente se ve en la terminal. Claude Code y Copilot corren con permisos
-acotados: leer, `git`, el `validate` y escribir solo el JSON del review (Copilot no puede acotar por argumentos,
-así que permite `npx` en general). Cursor corre con `--force` (no tiene
-flag para pasar una allowlist y sin él bloquearía el `validate`) y Gemini con `--yolo`. Si no hay agentes
-instalados, sigue con el portapapeles. Sin terminal interactiva usa el primer agente con su modelo por defecto.
-
-El agente tiene que estar logueado (p. ej. `claude /login` una vez).
+   `ANTHROPIC_MODEL`, `~/.cursor/cli-config.json` o `~/.copilot/settings.json`; si no hay, no se pasa `--model`).
+   También lista los conocidos (para Claude, los alias `opus` / `sonnet` / `haiku`; para Copilot, `auto`) y "Otro…"
+   para escribir un id. Por ACP, la lista sale de lo que ofrece el agente.
+
+Por defecto el agente corre por ACP en la web. Con `--headless`, el prompt va por stdin y la salida se ve en la
+terminal (Claude/Copilot con permisos acotados; Cursor con `--force`). Si no hay agentes instalados, sigue con el
+portapapeles. Sin terminal interactiva usa el primer agente con su modelo por defecto.
+
+Si el agente no está autenticado, la CLI pregunta **¿Querés iniciar sesión en {agente} ahora?** (al listar
+modelos y otra vez **antes de abrir la web** si ya elegiste agente), corre el login **en la misma terminal**,
+espera exit 0 y reintenta; si cancelás, sigue (lista fija de modelos / web con CTA). Con **Copilot** podés
+elegir **GitHub.com** o **Enterprise** (hostname); no se fuerza un host por env. En github.com, si tenés
+varias cuentas, elegí la corporativa en el browser del OAuth. En el header (arriba a la derecha) se muestra la **cuenta activa** del agente; el menú tiene
+**Cambiar cuenta** (en Copilot también cierra sesiones de `gh`, porque si no el logout OAuth no alcanza).
+Ojo: si tenés `GH_TOKEN` / `GITHUB_TOKEN` / `COPILOT_GITHUB_TOKEN` en el entorno, hay que sacarlos a mano.
 
 #### Por ACP, con la web (Claude Code, Cursor CLI, GitHub Copilot CLI)
 
-Si el agente elegido habla ACP, la CLI abre la UI enseguida y el agente corre dentro del server local. Claude Code
+Los agentes integrados corren por ACP: la CLI abre la UI enseguida y el agente vive dentro del server local. Claude Code
 va por el adaptador `@agentclientprotocol/claude-agent-acp` (se baja con `npx` la primera vez); Cursor
-(`cursor-agent acp`) y Copilot (`copilot --acp`) lo traen de fábrica. Codex y Gemini siguen por la terminal.
+(`cursor-agent acp`) y Copilot (`copilot --acp`) lo traen de fábrica.
 
 - El select de modelo muestra los que ofrece cada agente (se consultan por ACP la primera vez).
 - La web muestra lo que va haciendo (comandos, archivos que lee, plan). La terminal solo avisa fallos duros o JSON válido.
+- Autenticación ACP: el client anuncia `auth.terminal`; Cursor usa `authenticate`, Claude/Copilot abren login
+  interactivo (métodos `type: terminal` o `_meta.terminal-auth`) en la misma TTY desde la CLI (modelos + justo
+  antes de abrir la web), o como proceso oculto + browser OAuth desde la web vía **Iniciar sesión en {agente}**.
+  Si hace falta más tarde, la web usa **needs_auth**.
 - Al terminar cada turno, el server valida el JSON; si falta algo se lo pide al agente hasta dos veces y, cuando valida,
   la web abre el reporte.
 - Cada pedido de permiso pasa por una política fija: leer dentro del repo, escribir únicamente el JSON del review

package/bin/diff-review.mjs

@@ -13,13 +13,15 @@
 
 import { spawn, spawnSync } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { createServer } from 'node:net';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import * as p from '@clack/prompts';
 import { AGENTS, detectAgents, modelChoices, resolvedRunModel, runAgent } from '../lib/agents.mjs';
 import { listAcpModelsCached, supportsAcp } from '../lib/acp.mjs';
+import { readModelsCache } from '../lib/models-cache.mjs';
+import { isAuthRequiredError, withAgentLoginRetry } from '../lib/agent-login.mjs';
 import { buildAcpModelSelectOptions, sortModelSelectOptions } from '../lib/model-label.mjs';
 import { autocompleteEs } from '../lib/autocomplete-es.mjs';
 import { copyTextToClipboard } from '../lib/clipboard.mjs';
@@ -32,6 +34,46 @@ import { existingReviewOutput, waitForReviewOutput } from '../lib/wait-output.mj
 import { stampReviewProvenance } from '../lib/review-meta.mjs';
 import { runValidateCli } from '../lib/check-report.mjs';
 
+/**
+ * Copilot: elegir github.com vs Enterprise (el usuario elige; no se fuerza por env).
+ * @returns {Promise<string | false>} host vacío = github.com; false = canceló
+ */
+async function pickCopilotLoginHost() {
+	const where = await p.select({
+		message: '¿Con qué cuenta de GitHub querés iniciar sesión?',
+		options: [
+			{
+				value: 'github.com',
+				label: 'GitHub.com',
+				hint: 'Personal u organización en github.com — elegí la cuenta en el browser'
+			},
+			{
+				value: 'enterprise',
+				label: 'GitHub Enterprise',
+				hint: 'Host tipo empresa.ghe.com'
+			}
+		],
+		initialValue: 'github.com'
+	});
+	if (p.isCancel(where)) {
+		p.cancel('Cancelado.');
+		return false;
+	}
+	if (where === 'enterprise') {
+		const host = await p.text({
+			message: 'Hostname de Enterprise',
+			placeholder: 'empresa.ghe.com',
+			validate: (v) => (String(v || '').trim() ? undefined : 'Ingresá el hostname')
+		});
+		if (p.isCancel(host)) {
+			p.cancel('Cancelado.');
+			return false;
+		}
+		return String(host).trim();
+	}
+	return '';
+}
+
 const here = dirname(fileURLToPath(import.meta.url));
 const packageRoot = join(here, '..');
 // `DIFF_REVIEW_OUT=build-next` cuando `web/build` está bloqueado por un server en marcha (EBUSY en Windows).
@@ -43,6 +85,19 @@ const buildDir = (() => {
 })();
 const entry = join(buildDir, 'index.js');
 
+/** Versión del paquete instalado (la del package.json que viaja con el CLI). */
+const VERSION = (() => {
+	try {
+		return String(JSON.parse(readFileSync(join(packageRoot, 'package.json'), 'utf8')).version || '');
+	} catch {
+		return '';
+	}
+})();
+const TITLE = VERSION ? `diff-review v${VERSION}` : 'diff-review';
+
+/** Agentes cuyos modelos ya se consultaron en vivo en esta corrida: la sesión ACP anda y no hace falta otro probe. */
+const liveModelsOk = new Set();
+
 const DEFAULT_HOST = '127.0.0.1';
 const DEFAULT_PORT = 5190;
 
@@ -62,7 +117,7 @@ function resolveNodeBin() {
 }
 
 function printHelp() {
-	console.log(`diff-review — review de branch con tu agente + UI local.
+	console.log(`${TITLE} — review de branch con tu agente + UI local.
 
 Usage:
   diff-review [options]
@@ -75,9 +130,10 @@ un solo select lista el portapapeles y cada agente detectado.
 Si pasás --branch y --base juntos, saltea los selects.
 Con --agent: saltea esa lista; elegís un agente instalado y el modelo,
 y diff-review lo lanza con el prompt.
-Si el agente habla ACP (Claude Code), corre desde la UI web: ves el
-proceso en vivo y después podés preguntarle o pedirle cambios al reporte.
-Con --headless corre en la terminal como antes.
+Los agentes integrados (Claude Code, Cursor CLI, Copilot) corren por ACP
+desde la UI web: ves el proceso en vivo y después podés preguntarle o
+pedirle cambios al reporte. Si falta login, la CLI ofrece abrirlo en una
+terminal y reintentar. Con --headless corren en la terminal.
 Con --ui: abre la UI de inmediato (web-first).
 
 Options:
@@ -89,6 +145,7 @@ Options:
       --agent      Lanzar un agente instalado (${AGENTS.map((a) => a.bins[0]).join(', ')}) con el prompt
       --headless   Con agente: correrlo en la terminal (sin ACP ni chat en la web)
       --no-open    No abrir el navegador
+  -v, --version    Mostrar la versión
   -h, --help       Esta ayuda
 
 Requiere git en PATH. Los reportes viven en localStorage del navegador.
@@ -101,6 +158,7 @@ function parseArgs(argv) {
 		host: DEFAULT_HOST,
 		open: true,
 		help: false,
+		version: false,
 		ui: false,
 		agent: false,
 		headless: false,
@@ -110,6 +168,7 @@ function parseArgs(argv) {
 	for (let i = 0; i < argv.length; i++) {
 		const a = argv[i];
 		if (a === '-h' || a === '--help') opts.help = true;
+		else if (a === '-v' || a === '--version') opts.version = true;
 		else if (a === '--no-open') opts.open = false;
 		else if (a === '--ui') opts.ui = true;
 		else if (a === '--agent') opts.agent = true;
@@ -257,7 +316,7 @@ async function resolveBranchBase(launch, opts, pickOpts = {}) {
 
 	const options = branchOptions(launch.listed);
 	if (!pickOpts.skipIntro) {
-		p.intro('diff-review');
+		p.intro(TITLE);
 		p.log.info(launch.repo);
 	}
 
@@ -405,6 +464,7 @@ function copyPromptOrWarn(prompt) {
 
 /**
  * Opciones de modelo: las que ofrece el agente por ACP (si va a correr así) o, si no, la lista fija.
+ * Si ACP falla por auth, ofrece el login (misma TTY o proceso oculto), espera exit 0 y reintenta (misma lógica que la web).
  * @param {import('../lib/agents.mjs').DetectedAgent} agent
  * @param {{ acpCwd?: string }} opts
  */
@@ -415,26 +475,82 @@ async function modelOptions(agent, { acpCwd }) {
 		options: sortModelSelectOptions(fixed.options)
 	};
 	if (!acpCwd) return sortedFixed;
+
+	// Siempre se le pregunta al agente (tarda unos segundos, pero la lista es la real); la caché solo
+	// sirve de respaldo si la consulta falla.
+	const fetchModels = () => listAcpModelsCached(agent, { cwd: acpCwd, force: true });
+
+	/** Última lista conocida, aunque tenga más de 24 h; si no hay, la fija. */
+	const fallback = () => {
+		const hit = readModelsCache(agent.def.id, { ttlMs: Infinity });
+		if (!hit?.models.length) {
+			p.log.warn('Uso la lista fija de modelos.');
+			return sortedFixed;
+		}
+		p.log.warn(`Uso la última lista conocida (${hit.fetchedAt.slice(0, 10)}).`);
+		return buildAcpModelSelectOptions({ models: hit.models, currentModel: hit.currentModel }, fixed);
+	};
+
+	/** @param {{ models: { value: string, name: string }[], currentModel: string }} result */
+	const fromLive = (result) => {
+		liveModelsOk.add(agent.def.id);
+		if (!result.models.length) return sortedFixed;
+		return buildAcpModelSelectOptions(
+			{ models: result.models, currentModel: result.currentModel },
+			fixed
+		);
+	};
+
 	const spin = p.spinner();
 	spin.start(`Consultando los modelos de ${agent.def.label}`);
 	try {
-		const { models, currentModel, fromCache } = await listAcpModelsCached(agent, { cwd: acpCwd });
-		spin.stop(
-			fromCache
-				? `Modelos de ${agent.def.label} (caché)`
-				: `Modelos de ${agent.def.label}`
-		);
-		if (!models.length) return sortedFixed;
-		// Misma fusión/labels/orden que la UI.
-		return buildAcpModelSelectOptions({ models, currentModel }, fixed);
+		const result = await fetchModels();
+		spin.stop(`Modelos de ${agent.def.label} (${result.models.length})`);
+		return fromLive(result);
 	} catch (err) {
-		spin.stop(`No pude consultar los modelos (${err instanceof Error ? err.message.split('\n')[0] : err}).`);
-		return sortedFixed;
+		const detail = err instanceof Error ? err.message.split('\n')[0] : String(err);
+		spin.stop(`No pude consultar los modelos (${detail}).`);
+
+		if (!isInteractive() || !isAuthRequiredError(err)) return fallback();
+
+		const outcome = await withAgentLoginRetry(() => fetchModels(), {
+			agent,
+			cwd: acpCwd,
+			priorError: err,
+			askToLogin: async ({ message, agentLabel, displayCmd }) => {
+				p.log.warn(message);
+				const answer = await p.confirm({
+					message: `¿Querés iniciar sesión en ${agentLabel} ahora?`,
+					initialValue: true
+				});
+				if (p.isCancel(answer)) {
+					p.cancel('Cancelado.');
+					return false;
+				}
+				if (displayCmd) p.log.step(displayCmd);
+				return Boolean(answer);
+			},
+			pickCopilotHost: pickCopilotLoginHost,
+			onStatus: (msg) => p.log.info(msg)
+		});
+
+		if (outcome.ok) {
+			p.log.success(`Modelos de ${agent.def.label} (${outcome.value.models.length})`);
+			return fromLive(outcome.value);
+		}
+		if (outcome.cancelled) {
+			p.log.warn('Podés autenticarte después desde la web.');
+			return fallback();
+		}
+		const after = outcome.error instanceof Error ? outcome.error.message.split('\n')[0] : String(outcome.error);
+		p.log.warn(`No pude consultar los modelos tras el login (${after}).`);
+		return fallback();
 	}
 }
 
 /**
  * Modelo del agente: autocomplete con búsqueda; sin TTY, el default (string vacío).
+ * `""` es válido (= "Por defecto del agente", no se pasa --model); no usar ensureValue.
  * @param {import('../lib/agents.mjs').DetectedAgent} agent
  * @param {{ acpCwd?: string }} [opts] con `acpCwd`, la lista sale del agente por ACP
  */
@@ -442,17 +558,17 @@ async function pickModel(agent, opts = {}) {
 	if (!isInteractive()) return '';
 
 	const { options, initialValue } = await modelOptions(agent, opts);
-	return /** @type {string} */ (
-		ensureValue(
-			await autocompleteEs({
-				message: 'Modelo',
-				options,
-				initialValue,
-				placeholder: 'opus, sonnet, gpt…'
-			}),
-			'modelo'
-		)
-	);
+	const value = await autocompleteEs({
+		message: 'Modelo',
+		options,
+		initialValue,
+		placeholder: 'opus, sonnet, gpt…'
+	});
+	if (p.isCancel(value)) {
+		p.cancel('Cancelado.');
+		process.exit(0);
+	}
+	return /** @type {string} */ (value ?? '');
 }
 
 /**
@@ -572,6 +688,76 @@ async function runAgentAndWait(agent, { repo, prompt, model, outputFilename, use
 	return /** @type {{ path: string }} */ (result);
 }
 
+/**
+ * Antes de abrir la web: forzar un probe ACP (sin caché) y, si hace falta auth, login in-flow en esta terminal.
+ * Así no llegamos a LiveReviewView sin sesión cuando el usuario ya eligió el agente en la CLI.
+ * @param {import('../lib/agents.mjs').DetectedAgent} agent
+ * @param {string} repo
+ * @param {boolean} useClack
+ * @returns {Promise<boolean>} true si el probe quedó ok (logueado o ya lo estaba)
+ */
+async function ensureAgentAuthBeforeUi(agent, repo, useClack) {
+	// Si recién listamos los modelos en vivo, la sesión ya anduvo: no hace falta arrancar el agente otra vez.
+	if (liveModelsOk.has(agent.def.id)) return true;
+	const probe = () => listAcpModelsCached(agent, { cwd: repo, force: true });
+	try {
+		await probe();
+		return true;
+	} catch (err) {
+		if (!isInteractive() || !isAuthRequiredError(err)) {
+			const detail = err instanceof Error ? err.message.split('\n')[0] : String(err);
+			if (useClack) p.log.warn(detail);
+			else console.warn(detail);
+			return false;
+		}
+
+		const outcome = await withAgentLoginRetry(() => probe(), {
+			agent,
+			cwd: repo,
+			priorError: err,
+			askToLogin: async ({ message, agentLabel }) => {
+				if (useClack) {
+					p.log.warn(message);
+					const answer = await p.confirm({
+						message: `¿Querés iniciar sesión en ${agentLabel} ahora?`,
+						initialValue: true
+					});
+					if (p.isCancel(answer)) {
+						p.cancel('Cancelado.');
+						return false;
+					}
+					return Boolean(answer);
+				}
+				console.warn(message);
+				return true;
+			},
+			pickCopilotHost: useClack ? pickCopilotLoginHost : async () => '',
+			onStatus: (msg) => {
+				if (useClack) p.log.info(msg);
+				else console.log(msg);
+			}
+		});
+
+		if (outcome.ok) {
+			if (useClack) p.log.success(`Sesión de ${agent.def.label} lista.`);
+			else console.log(`Sesión de ${agent.def.label} lista.`);
+			return true;
+		}
+		if (outcome.cancelled) {
+			const warn =
+				'Sin iniciar sesión: la web va a pedir autenticación al lanzar el agente.';
+			if (useClack) p.log.warn(warn);
+			else console.warn(warn);
+			return false;
+		}
+		const after =
+			outcome.error instanceof Error ? outcome.error.message.split('\n')[0] : String(outcome.error);
+		if (useClack) p.log.warn(after);
+		else console.warn(after);
+		return false;
+	}
+}
+
 /**
  * El agente corre dentro del server de la UI (ACP): la web muestra el proceso y abre el reporte; la terminal ve un
  * resumen. La sesión queda viva para preguntas y cambios desde el reporte.
@@ -580,6 +766,7 @@ async function runAgentAndWait(agent, { repo, prompt, model, outputFilename, use
  * @param {{ host: string, port: number, open: boolean }} opts
  */
 async function runAgentInUi(agent, { repo, branch, base, model, outputFilename, useClack }, opts) {
+	await ensureAgentAuthBeforeUi(agent, repo, useClack);
 	const id = randomUUID();
 	const msg = `Lanzando ${agent.def.label} (${model || 'modelo por defecto'}). El progreso se ve en la web; Ctrl+C corta.`;
 	if (useClack) p.outro(msg);
@@ -746,6 +933,10 @@ async function main() {
 	}
 
 	const opts = parseArgs(rawArgv);
+	if (opts.version) {
+		console.log(VERSION || 'desconocida');
+		process.exit(0);
+	}
 	if (opts.help) {
 		printHelp();
 		process.exit(0);
@@ -844,7 +1035,7 @@ async function main() {
 	const existing = isInteractive() ? existingReviewOutput(launch.repo, outputFilename) : null;
 	const useClack = prompted || (isInteractive() && (detected.length > 0 || existing != null));
 	// Con flags de branch/base no hubo intro, pero estos selects abren sesión de Clack igual.
-	if (useClack && !prompted) p.intro('diff-review');
+	if (useClack && !prompted) p.intro(TITLE);
 
 	let result = existing ? await reuseExistingReview(existing, outputFilename) : null;
 	/** @type {import('../lib/agents.mjs').DetectedAgent | null} */

package/lib/acp.mjs

@@ -9,9 +9,27 @@ import { Readable, Writable } from "node:stream";
 import * as acp from "@agentclientprotocol/sdk";
 import { spawnCommand } from "./agents.mjs";
 import { permissionOutcome } from "./acp-policy.mjs";
-import { looksLikeAuthFailure } from "./agent-login.mjs";
+import { authFailureMessage, groupAuthMethods, looksLikeAuthFailure } from "./agent-login.mjs";
 import { readModelsCache, writeModelsCache } from "./models-cache.mjs";
 
+/**
+ * session/new (u otra op) requiere login interactivo (terminal / terminal-meta).
+ * No es un fallo genérico: la UI debe abrir el login y reintentar.
+ */
+export class AcpAuthRequiredError extends Error {
+  /**
+   * @param {string} message
+   * @param {{ methods?: any[], agentId?: string, agentLabel?: string }} [info]
+   */
+  constructor(message, info = {}) {
+    super(message);
+    this.name = "AcpAuthRequiredError";
+    this.methods = Array.isArray(info.methods) ? info.methods : [];
+    this.agentId = info.agentId || "";
+    this.agentLabel = info.agentLabel || "";
+  }
+}
+
 /**
  * @typedef {import('./agents.mjs').DetectedAgent} DetectedAgent
  * @typedef {import('@agentclientprotocol/sdk').SessionUpdate} SessionUpdate
@@ -40,9 +58,11 @@ import { readModelsCache, writeModelsCache } from "./models-cache.mjs";
  *   models: ModelOption[],
  *   currentModel: string,
  *   modelWarning?: string,
+ *   supportsLogout: boolean,
  *   setModel: (model: string) => Promise<{ currentModel: string, warning?: string }>,
  *   prompt: (text: string) => Promise<{ stopReason: string }>,
  *   cancel: () => Promise<void>,
+ *   logout: () => Promise<void>,
  *   close: () => void,
  *   closed: Promise<void>,
  *   stderrTail: () => string,
@@ -84,7 +104,7 @@ const ACP_START_TIMEOUT_MS = 90_000;
  * @returns {Promise<AcpSession>}
  */
 export async function startAcpSession(agent, opts) {
-  if (!supportsAcp(agent)) throw new Error(`${agent.def.label} no tiene modo ACP.`);
+  if (!supportsAcp(agent)) throw new Error(`${agent.def.label} no se puede usar desde la web.`);
   const { file, args, env, sessionMeta } = agent.def.acp({ path: agent.path });
   const child = spawnCommand(file, args, {
     cwd: opts.cwd,
@@ -163,15 +183,27 @@ export async function startAcpSession(agent, opts) {
   try {
     const init = await conn.agent.request(acp.methods.agent.initialize, {
       protocolVersion: acp.PROTOCOL_VERSION,
-      clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
+      clientCapabilities: {
+        fs: { readTextFile: false, writeTextFile: false },
+        // terminal* ACP (PTY del agente): no. auth.terminal = login interactivo en una terminal nuestra.
+        terminal: false,
+        auth: {
+          terminal: true,
+        },
+        // Claude mira `clientCapabilities._meta["terminal-auth"]` (no `auth._meta`) para rellenar
+        // method._meta["terminal-auth"] con node+adapter --cli …; sin esto solo manda type:terminal + args.
+        _meta: { "terminal-auth": true },
+      },
       clientInfo: { name: "diff-review", version: "0" },
     });
 
     const authMethods = Array.isArray(init.authMethods) ? init.authMethods : [];
-    /** Métodos donde el agente maneja el login por `authenticate` (no terminal interactiva). */
-    const agentAuthMethods = authMethods.filter((m) => m && (!m.type || m.type === "agent") && m.id);
+    const grouped = groupAuthMethods(authMethods);
+    /** Solo type agent (p. ej. Cursor `cursor_login`). Nunca terminal ni Copilot `_meta.terminal-auth`. */
+    const agentAuthMethods = grouped.agent;
+    const interactiveAuthMethods = [...grouped.terminal, ...grouped.terminalMeta];
 
-    /** Si session/new falla por auth, pedimos `authenticate` una vez y reintentamos. */
+    /** Si session/new falla por auth, pedimos `authenticate` una vez (métodos agent) y reintentamos. */
     const tryAuthenticate = async () => {
       for (const method of agentAuthMethods) {
         try {
@@ -184,6 +216,18 @@ export async function startAcpSession(agent, opts) {
       return false;
     };
 
+    const authRequired = (msg) => {
+      const label = agent.def.label;
+      const friendly =
+        authFailureMessage(agent.def.id, label, msg) ||
+        `Necesitás iniciar sesión en ${label}.`;
+      return new AcpAuthRequiredError(friendly, {
+        methods: interactiveAuthMethods.length ? interactiveAuthMethods : authMethods,
+        agentId: agent.def.id,
+        agentLabel: label,
+      });
+    };
+
     const openNewSession = async () => {
       try {
         return await conn.agent.request(acp.methods.agent.session.new, {
@@ -193,13 +237,20 @@ export async function startAcpSession(agent, opts) {
         });
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        if (agentAuthMethods.length && looksLikeAuthFailure(msg) && (await tryAuthenticate())) {
+        if (!looksLikeAuthFailure(msg)) throw err;
+
+        // Cursor (y similares): authenticate + retry. No llamar authenticate para terminal / Copilot.
+        if (agentAuthMethods.length && (await tryAuthenticate())) {
           return await conn.agent.request(acp.methods.agent.session.new, {
             cwd: opts.cwd,
             mcpServers: [],
             ...(sessionMeta ? { _meta: sessionMeta } : {}),
           });
         }
+
+        if (interactiveAuthMethods.length || agentAuthMethods.length || looksLikeAuthFailure(msg)) {
+          throw authRequired(msg);
+        }
         throw err;
       }
     };
@@ -237,7 +288,7 @@ export async function startAcpSession(agent, opts) {
       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.` };
+        return { currentModel, warning: `El agente no deja elegir el modelo; usa el suyo.` };
       }
       if (!models.options.some((o) => o.value === wanted)) {
         return {
@@ -261,6 +312,8 @@ export async function startAcpSession(agent, opts) {
       if (applied.warning) modelWarning = applied.warning;
     }
 
+    const supportsLogout = Boolean(init.agentCapabilities?.auth?.logout);
+
     clearTimeout(timer);
     return {
       sessionId,
@@ -269,6 +322,7 @@ export async function startAcpSession(agent, opts) {
       get currentModel() {
         return currentModel;
       },
+      supportsLogout,
       ...(modelWarning ? { modelWarning } : {}),
       setModel,
       prompt: async (text) => {
@@ -279,6 +333,13 @@ export async function startAcpSession(agent, opts) {
         return { stopReason: String(res.stopReason) };
       },
       cancel: () => conn.agent.notify(acp.methods.agent.session.cancel, { sessionId }),
+      /** ACP `logout` si el agente lo anunció; no garantiza nada sobre credenciales de `gh`. */
+      logout: async () => {
+        if (!supportsLogout) {
+          throw new Error(`${agent.def.label} no admite cerrar sesión desde acá.`);
+        }
+        await conn.agent.request(acp.methods.agent.logout, {});
+      },
       close,
       closed: conn.closed,
       stderrTail: () => stderr,
@@ -286,13 +347,28 @@ export async function startAcpSession(agent, opts) {
   } catch (err) {
     clearTimeout(timer);
     close();
+    if (err instanceof AcpAuthRequiredError) throw err;
     const tail = stderr.trim().split(/\r?\n/).slice(-8).join("\n");
     if (timedOut) {
       const msg = `Timeout (${Math.round(timeoutMs / 1000)}s) al lanzar ${agent.def.label}. ¿Está autenticado el CLI?`;
-      throw new Error(tail ? `${msg}\n${tail}` : msg);
+      const full = tail ? `${msg}\n${tail}` : msg;
+      if (looksLikeAuthFailure(full)) {
+        throw new AcpAuthRequiredError(
+          authFailureMessage(agent.def.id, agent.def.label, full) || full,
+          { agentId: agent.def.id, agentLabel: agent.def.label }
+        );
+      }
+      throw new Error(full);
     }
     const reason = err instanceof Error ? err.message : String(err);
-    throw new Error(tail ? `${reason}\n${tail}` : reason);
+    const full = tail ? `${reason}\n${tail}` : reason;
+    if (looksLikeAuthFailure(full)) {
+      throw new AcpAuthRequiredError(
+        authFailureMessage(agent.def.id, agent.def.label, full) || full,
+        { agentId: agent.def.id, agentLabel: agent.def.label }
+      );
+    }
+    throw new Error(full);
   }
 }