@jpkme/diff-review 0.1.16 → 0.1.17

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

@@ -20,6 +20,7 @@ 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 { 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 +33,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).
@@ -75,9 +116,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:
@@ -405,6 +447,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 +458,85 @@ async function modelOptions(agent, { acpCwd }) {
 		options: sortModelSelectOptions(fixed.options)
 	};
 	if (!acpCwd) return sortedFixed;
+
+	/** @param {boolean} [force] */
+	const fetchModels = (force = false) => listAcpModelsCached(agent, { cwd: acpCwd, force });
+
 	const spin = p.spinner();
 	spin.start(`Consultando los modelos de ${agent.def.label}`);
-	try {
-		const { models, currentModel, fromCache } = await listAcpModelsCached(agent, { cwd: acpCwd });
+
+	/**
+	 * @param {{ models: { value: string, name: string }[], currentModel: string, fromCache: boolean }} result
+	 */
+	const finishOk = (result) => {
 		spin.stop(
-			fromCache
+			result.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);
+		if (!result.models.length) return sortedFixed;
+		return buildAcpModelSelectOptions(
+			{ models: result.models, currentModel: result.currentModel },
+			fixed
+		);
+	};
+
+	try {
+		return finishOk(await fetchModels(false));
 	} catch (err) {
-		spin.stop(`No pude consultar los modelos (${err instanceof Error ? err.message.split('\n')[0] : err}).`);
+		const detail = err instanceof Error ? err.message.split('\n')[0] : String(err);
+		spin.stop(`No pude consultar los modelos (${detail}).`);
+
+		// Sin TTY o no es auth: misma degradación de antes.
+		if (!isInteractive() || !isAuthRequiredError(err)) return sortedFixed;
+
+		const outcome = await withAgentLoginRetry(() => fetchModels(true), {
+			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) {
+			const result = outcome.value;
+			p.log.success(
+				result.fromCache
+					? `Modelos de ${agent.def.label} (caché)`
+					: `Modelos de ${agent.def.label}`
+			);
+			if (!result.models.length) return sortedFixed;
+			return buildAcpModelSelectOptions(
+				{ models: result.models, currentModel: result.currentModel },
+				fixed
+			);
+		}
+		if (outcome.cancelled) {
+			p.log.warn('Siguiendo con la lista fija de modelos. Podés autenticarte después desde la web.');
+			return sortedFixed;
+		}
+		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}). Sigo con la lista fija.`);
 		return sortedFixed;
 	}
 }
 
 /**
  * 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 +544,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 +674,74 @@ 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) {
+	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 +750,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);

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);
   }
 }