@hoilab/ada-cli 0.84.21 → 0.85.0

package/dist/cli/serve-command.js

@@ -0,0 +1,568 @@
+/**
+ * Subcomandos que no abren el TUI: `serve`, `sessions`, `session`, `attach`,
+ * `acp`, `schedule`, `refine` y `telegram`.
+ *
+ * Se mantienen en un fichero propio y el enganche en `main.ts` es un import y
+ * una llamada, para no engordar la superficie de conflicto con upstream. `acp`
+ * entra aquí por lo mismo: añadirlo cuesta cero hunks nuevos contra upstream.
+ */
+import { join } from "node:path";
+import { getAgentDir } from "../config.js";
+/**
+ * Separa `--socket <ruta>` de los argumentos de la operación.
+ *
+ * Existe porque sin ella se colaban dentro: `session x rename --socket /tmp/s`
+ * acababa poniéndole a la sesión el nombre "--socket /tmp/s". Se exporta para
+ * poder probarlo sin levantar un servidor.
+ */
+export function parseSessionOpArgs(args) {
+    const socketIndex = args.indexOf("--socket");
+    const cleaned = socketIndex >= 0 ? args.filter((_, i) => i !== socketIndex && i !== socketIndex + 1) : args;
+    const [, sessionId, op, ...rest] = cleaned;
+    return { sessionId, op, rest };
+}
+/**
+ * Por qué lo que ha llegado del modelo NO es una respuesta, o `null` si sí lo es.
+ *
+ * DOS formas de no serlo, y solo se miraba una:
+ *
+ *   - `vacia`: no ha llegado texto. Ésta ya se miraba.
+ *   - `cortada`: el proveedor se murió con el stream YA EMPEZADO. Llega texto,
+ *     así que la guarda de «texto vacío» no lo ve, y el trozo sale como si
+ *     fuera la respuesta buena.
+ *
+ * Reproducido con un servidor que emite un trozo y destruye el socket. La
+ * respuesta que devuelve el SDK es literalmente:
+ *
+ *     { stopReason: "error", errorMessage: "terminated",
+ *       texto: "reintenta las peti" }
+ *
+ * Y con eso, `ada-cli commit --hacer` dejó ESTO en la historia de git, con
+ * salida 0 y stderr vacío:
+ *
+ *     [main c3a409b] reintenta las peti
+ *      1 file changed, 7 insertions(+)
+ *
+ * `review` entra por la misma puerta: media revisión sale como la revisión
+ * entera. Es exactamente el fallo que esta función dice impedir, colándose por
+ * el lado que no se miraba.
+ *
+ * El trozo se DESCARTA entero a propósito: media revisión no es una revisión y
+ * medio titular no es un titular. `length` NO cuenta como corte — ahí el modelo
+ * terminó de hablar, aunque fuera por el tope de tokens, y rechazarlo sería un
+ * falso positivo que rompe la cara buena.
+ */
+export function porQueNoEsRespuesta(stopReason, texto) {
+    if (stopReason === "error" || stopReason === "aborted")
+        return "cortada";
+    if (texto.trim() === "")
+        return "vacia";
+    return null;
+}
+/**
+ * Una llamada al modelo configurado, lista para inyectar en un subcomando.
+ *
+ * Vive aquí y no en cada comando porque `review` y `commit` la necesitan igual,
+ * y sobre todo porque la parte que importa —una respuesta vacía o cortada es un
+ * FALLO, no un resultado— no puede depender de que cada comando se acuerde de
+ * escribirla. Ya nos costó cuatro revisiones falsamente limpias: eran 429 del
+ * proveedor que se leyeron como "tu código está limpio".
+ *
+ * `advertencia` es lo que cambia entre comandos: la frase que evita que el
+ * usuario interprete el fallo como un veredicto.
+ */
+function crearLlamadaAlModelo(args, agentDir, advertencia) {
+    return async (sistema, usuario) => {
+        const { ModelRuntime } = await import("../core/model-runtime.js");
+        const { resolveCliModel } = await import("../core/model-resolver.js");
+        const { SettingsManager } = await import("../core/settings-manager.js");
+        const { homedir } = await import("node:os");
+        const modelRuntime = await ModelRuntime.create();
+        // El modelo de los ajustes, que es el que el usuario ya eligió. Sin esto
+        // habría que pasarlo a mano en cada llamada, y un comando que exige
+        // recordar un identificador de modelo no lo lanza nadie.
+        const ajustes = SettingsManager.create(homedir(), agentDir);
+        // `--model proveedor/modelo` gana a los ajustes: un CI necesita fijar con
+        // qué se ejecuta, y no depender de lo que tenga elegido quien lo configuró.
+        const iModelo = args.indexOf("--model");
+        const spec = iModelo >= 0 ? args[iModelo + 1] : undefined;
+        const barra = spec?.indexOf("/") ?? -1;
+        const { model } = resolveCliModel({
+            modelRuntime,
+            cliProvider: barra > 0 ? spec?.slice(0, barra) : ajustes.getDefaultProvider(),
+            cliModel: barra > 0 ? spec?.slice(barra + 1) : ajustes.getDefaultModel(),
+        });
+        if (!model) {
+            throw new Error("No hay modelo configurado. Abre `ada-cli` y elige uno con /login o /model.");
+        }
+        const { contentText } = await import("@earendil-works/pi-ai");
+        const respuesta = await modelRuntime.completeSimple(model, {
+            systemPrompt: sistema,
+            messages: [{ role: "user", content: usuario }],
+        });
+        const texto = contentText(respuesta.content, "");
+        // Ni vacía ni cortada. Lo encontró el propio `ada-cli review` revisando
+        // este mismo diff, y tenía razón: cuatro de cinco ejecuciones sobre un
+        // fallo sembrado decían "el revisor no ha encontrado nada" cuando lo que
+        // pasaba era un 429 del proveedor.
+        const motivo = porQueNoEsRespuesta(respuesta.stopReason, texto);
+        if (motivo) {
+            // El error del proveedor, clasificado. Antes se le enseñaba al usuario el
+            // volcado JSON entero —400 caracteres con tres cosas útiles dentro— y la
+            // mayoría no lo lee: un error que no se lee se interpreta como "esto no
+            // funciona".
+            const { clasificarError, explicarError } = await import("../core/errores/proveedor.js");
+            const clasificado = clasificarError({ mensaje: respuesta.errorMessage ?? respuesta.stopReason });
+            // Decir CUÁNTO llegó y que se tira. Callarlo dejaría al usuario creyendo
+            // que el proveedor no contestó nada, cuando lo que pasó es que contestó
+            // a medias y hemos decidido no fiarnos.
+            const aMedias = motivo === "cortada" && texto.trim() !== ""
+                ? `\nLa respuesta llegó a medias (${texto.trim().length} caracteres) y se DESCARTA: media respuesta no es una respuesta.`
+                : "";
+            throw new Error(`${explicarError(clasificado)}${aMedias}\n${advertencia}`);
+        }
+        return texto;
+    };
+}
+/**
+ * Los subcomandos que se despachan aquí. La fuente de verdad, exportada.
+ *
+ * Se exporta para que la prueba de la ayuda pueda recorrer ESTA lista y no una
+ * copia. Con la copia, añadir un subcomando nuevo sin documentarlo dejaba la
+ * prueba en verde: se comprobó añadiendo `fantasma` a la lista y sin tocar la
+ * ayuda, y pasaron 21 de 21. La prueba decía mirar la fuente de verdad y miraba
+ * su propia copia, que es el mismo defecto que dice prevenir.
+ */
+export const SUBCOMANDOS_SERVE = [
+    "serve",
+    "attach",
+    "sessions",
+    "session",
+    "acp",
+    "schedule",
+    "refine",
+    "telegram",
+    "undo",
+    "usage",
+    "wiki",
+    "audit",
+    "review",
+    "import",
+    "discover",
+    "hashline",
+    "cleanse",
+    "banco",
+    "commit",
+    // `computer` faltaba mientras `runServeCommand` lo manejaba y `printServeHelp`
+    // lo anunciaba: `ada-cli computer status` no llegaba nunca a su rama, se iba
+    // al camino normal y salía "No API key found" con código 0 — capacidad
+    // construida, documentada y desenchufada. Se perdió justamente porque la
+    // lista vivía copiada en dos sitios; por eso ahora es UNA constante y la
+    // guarda de `test/serve-command-lista.test.ts` la compara con el despacho.
+    "computer",
+    // `politica`/`policy`: el ámbito de configuración que el usuario no puede
+    // editar. Va en la lista, en `ownsItsHelp` y en la ayuda a la vez, que son
+    // los tres sitios donde `computer` se quedó a medias.
+    "politica",
+    "policy",
+    "telemetria",
+    "telemetry",
+];
+export function isServeCommand(args) {
+    return SUBCOMANDOS_SERVE.includes(args[0] ?? "");
+}
+export function printServeHelp() {
+    console.log(`Uso:
+  ada-cli serve [--socket <ruta>]   Hospeda sesiones residentes; el trabajo sobrevive al cierre del terminal
+  ada-cli serve --broker [--escuchar host:puerto] [--credenciales <archivo.json>]
+                                     Broker de credenciales: las claves salen del portátil de cada dev
+  ada-cli sessions                  Lista las sesiones conocidas
+  ada-cli attach <id> [--watch]     Reconecta a una sesión servida (--watch = solo mirar)
+  ada-cli session <id> <op>         compact | rename <nombre> | fork | kill | ops
+  ada-cli acp                       Habla Agent Client Protocol por stdio (Zed y otros editores)
+  ada-cli schedule <acción>         Trabajo recurrente (corre dentro de 'serve')
+  ada-cli refine [sessionId]        Extrae lecciones durables de una sesión al harness
+  ada-cli telegram                  Controla las sesiones residentes desde Telegram
+  ada-cli undo [--dry-run]          Deshace los cambios de ficheros del último turno
+  ada-cli usage [--days N]          Tokens y coste reales, por modelo, proyecto y día
+  ada-cli wiki <index|check>        Wiki del repositorio con citas que caducan
+  ada-cli computer <status|install> Motor de control del ordenador y sus permisos
+  ada-cli review [--sarif <f>]      Revisa el diff con hallazgos anclados al código y SARIF 2.1.0
+  ada-cli audit <...>               Registro de cumplimiento: solo lee ficheros, contesta aunque el resto esté caído
+  ada-cli politica                  Política del equipo: el único ámbito que el usuario no puede editar
+                                    (en inglés: ada-cli policy)
+  ada-cli telemetria [--cuerpo]     Exportación OTLP: qué sale de esta máquina, y qué no
+                                    (en inglés: ada-cli telemetry)
+  ada-cli import <...>              Trae sesiones y configuración de otras herramientas
+  ada-cli discover                  Lista MCP, skills y comandos que otras herramientas dejaron en el proyecto
+  ada-cli hashline <tag|apply>      Formato de edición anclado por hash de línea
+  ada-cli cleanse [--dry-run]       Detecta y arregla en paralelo los diagnósticos de lint/typecheck/test
+  ada-cli banco <generar|run|comparar>  Banco de fiabilidad de edición: casos, ejecución y comparación
+  ada-cli commit [--hacer]          Mensaje de commit de lo que hay en el índice, por map-reduce sobre el diff
+
+El socket vive por defecto en <agentDir>/server.sock y solo lo puede leer tu usuario.`);
+}
+/**
+ * Ejecuta el subcomando. Devuelve true si consumió los argumentos.
+ *
+ * Las dependencias pesadas se cargan de forma perezosa: un arranque normal del
+ * CLI no debe pagar el coste de importar el servidor.
+ */
+export async function runServeCommand(args) {
+    if (!isServeCommand(args))
+        return false;
+    // La ayuda genérica solo cubre los subcomandos que NO traen la suya. Antes
+    // se comprobaba primero y se comía a las demás: `refine --help` acababa
+    // enseñando la ayuda de `serve`.
+    const ownsItsHelp = [
+        "acp",
+        "schedule",
+        "refine",
+        "telegram",
+        "undo",
+        "usage",
+        "wiki",
+        "computer",
+        "audit",
+        "politica",
+        "policy",
+        "telemetria",
+        "telemetry",
+        "review",
+        "import",
+        "discover",
+        "hashline",
+        "cleanse",
+        "banco",
+        "commit",
+    ].includes(args[0] ?? "");
+    if (!ownsItsHelp && (args.includes("--help") || args.includes("-h"))) {
+        printServeHelp();
+        return true;
+    }
+    const agentDir = getAgentDir();
+    // `audit` va lo primero: solo lee ficheros, no necesita socket ni servidor,
+    // y tiene que poder contestar aunque el resto esté caído — un registro de
+    // cumplimiento que exige que el producto arranque no sirve de mucho.
+    const { runPoliticaCommand } = await import("./politica-command.js");
+    if (await runPoliticaCommand(args))
+        return true;
+    const { runTelemetriaCommand } = await import("./telemetria-command.js");
+    if (await runTelemetriaCommand(args, agentDir))
+        return true;
+    const { runAuditCommand } = await import("./audit-command.js");
+    if (await runAuditCommand(args, agentDir))
+        return true;
+    // `discover` tampoco necesita servidor: solo lee ficheros de otras
+    // herramientas en el cwd (MCP, skills, comandos de barra).
+    const { runDiscoverCommand } = await import("./discover-command.js");
+    if (await runDiscoverCommand(args))
+        return true;
+    // `import` tampoco necesita servidor: lee ficheros de otras herramientas y
+    // escribe los nuestros.
+    if (args[0] === "import") {
+        const { runImportCommand } = await import("./import-command.js");
+        const { randomUUID } = await import("node:crypto");
+        return runImportCommand(args, agentDir, () => randomUUID());
+    }
+    // Frontera de red. `audit`, `discover` e `import` solo leen y escriben
+    // ficheros, y cargar `undici` para ellos cuesta 221 módulos medidos (`discover`
+    // pasaba de 120 a 341). Todo lo que va DEBAJO puede hablar por red, así que el
+    // dispatcher se configura aquí.
+    //
+    // El sentido en el que se estropea es el bueno a propósito: un subcomando nuevo
+    // se añade debajo y recibe el dispatcher. Subirlo por encima de esta línea es
+    // lo que hay que justificar, no bajarlo.
+    const { configureHttpDispatcher } = await import("../core/http-dispatcher.js");
+    configureHttpDispatcher();
+    // `cleanse` tampoco necesita servidor: detecta comprobadores del proyecto,
+    // los ejecuta y lanza subagentes de reparación directamente.
+    if (args[0] === "cleanse") {
+        const { runCleanseCommand } = await import("./cleanse-command.js");
+        return runCleanseCommand(args, agentDir);
+    }
+    // `banco` tampoco necesita servidor: `generar`/`comparar` solo leen y
+    // escriben ficheros; `run` abre sus propias sesiones de agente puntuales.
+    if (args[0] === "banco") {
+        const { runBancoCommand } = await import("./banco-command.js");
+        return runBancoCommand(args);
+    }
+    // `review` y `commit` necesitan el modelo, así que se les pasa la llamada ya
+    // construida. La lógica vive en `core/revision/` y `core/commit/`, que se
+    // pueden probar sin red.
+    if (args[0] === "review") {
+        const { runReviewCommand } = await import("./review-command.js");
+        return await runReviewCommand(args, {
+            revisar: crearLlamadaAlModelo(args, agentDir, "NO se ha revisado el diff. Esto no significa que esté limpio."),
+        });
+    }
+    // `commit` tampoco necesita servidor: lee el índice de git, resume cada
+    // fichero por separado (map) y sintetiza el mensaje (reduce).
+    if (args[0] === "commit") {
+        const { runCommitCommand } = await import("./commit-command.js");
+        return await runCommitCommand(args, {
+            llamar: crearLlamadaAlModelo(args, agentDir, "NO se ha generado ningún mensaje. El índice sigue intacto."),
+        });
+    }
+    // `acp` va antes de resolver el socket: no usa ninguno, habla JSON-RPC por
+    // stdio. Y sobre todo, no puede escribir NADA en stdout antes de arrancar —
+    // stdout es el cable.
+    if (args[0] === "acp") {
+        if (args.includes("--help") || args.includes("-h")) {
+            console.log(`Uso:
+  ada-cli acp [--model <provider/model>]    Habla Agent Client Protocol por stdio
+
+Pensado para que lo lance un editor (Zed y otros clientes ACP), no para
+ejecutarlo a mano: stdout es el cable JSON-RPC. Configúralo como comando del
+agente en tu editor.`);
+            return true;
+        }
+        const { runAcpMode } = await import("../modes/acp/acp-mode.js");
+        const { createAgentSession } = await import("../core/sdk.js");
+        // `--model provider/model`. Se parte por la PRIMERA barra: los ids de
+        // modelo pueden llevar más (openrouter/stealth/ox-alpha).
+        const modelIndex = args.indexOf("--model");
+        const modelSpec = modelIndex >= 0 ? args[modelIndex + 1] : undefined;
+        let model;
+        if (modelSpec) {
+            const slash = modelSpec.indexOf("/");
+            if (slash <= 0) {
+                process.stderr.write(`[acp] --model debe ser 'provider/model' (recibido: ${modelSpec}).\n`);
+                process.exitCode = 1;
+                return true;
+            }
+            const { ModelRuntime } = await import("../core/model-runtime.js");
+            const runtime = await ModelRuntime.create({
+                authPath: join(agentDir, "auth.json"),
+                modelsPath: join(agentDir, "models.json"),
+            });
+            model = runtime.getModel(modelSpec.slice(0, slash), modelSpec.slice(slash + 1));
+            if (!model) {
+                // Fallar aquí y no más tarde: arrancar con el modelo equivocado y no
+                // decirlo produce una prueba que parece pasar y no prueba nada.
+                process.stderr.write(`[acp] modelo no encontrado: ${modelSpec}\n`);
+                process.exitCode = 1;
+                return true;
+            }
+        }
+        await runAcpMode({
+            createSession: async ({ cwd }) => {
+                const { session } = await createAgentSession({ cwd, agentDir, model });
+                return session;
+            },
+        });
+        return true;
+    }
+    // Ni `schedule` ni `refine` usan el socket: uno escribe el fichero de jobs
+    // que `serve` lee, y el otro trabaja sobre una sesión en disco.
+    if (args[0] === "schedule") {
+        const { runScheduleCommand } = await import("./schedule-command.js");
+        return runScheduleCommand(args);
+    }
+    if (args[0] === "refine") {
+        const { runRefineCommand } = await import("./refine-command.js");
+        return runRefineCommand(args);
+    }
+    if (args[0] === "telegram") {
+        const { runTelegramCommand } = await import("./telegram-command.js");
+        return runTelegramCommand(args);
+    }
+    if (args[0] === "undo") {
+        const { runUndoCommand } = await import("./undo-command.js");
+        return runUndoCommand(args, agentDir);
+    }
+    if (args[0] === "usage") {
+        const { runUsageCommand } = await import("./usage-command.js");
+        return runUsageCommand(args, agentDir);
+    }
+    if (args[0] === "wiki") {
+        const { runWikiCommand } = await import("./wiki-command.js");
+        return runWikiCommand(args);
+    }
+    if (args[0] === "computer") {
+        const { runComputerCommand } = await import("./computer-command.js");
+        return runComputerCommand(args);
+    }
+    if (args[0] === "hashline") {
+        const { runHashlineCommand } = await import("./hashline-command.js");
+        return runHashlineCommand(args);
+    }
+    // `serve --broker`: modo alternativo, no usa el socket Unix de sesiones. Es
+    // lo que hace viable el hueco sin construir un producto servidor nuevo — un
+    // equipo que quiera centralizar credenciales levanta esto, y quien no
+    // quiera no paga nada porque el flag no existe hasta que se pide.
+    if (args[0] === "serve" && args.includes("--broker")) {
+        const { CredencialPool } = await import("../core/credenciales/pool.js");
+        const { iniciarServidorBroker, DEFAULT_BROKER_BIND } = await import("../core/credenciales/servidor.js");
+        const { LibroDeSesion } = await import("../core/audit/libro.js");
+        const { readFile } = await import("node:fs/promises");
+        // Fallar cerrado en el propio CLI, antes de tocar el pool o el fichero:
+        // un broker sin bearer no debe ni intentar arrancar. `iniciarServidorBroker`
+        // repite esta comprobación (es la que de verdad importa, por si algún día
+        // se llama sin pasar por este CLI) — dos capas, un solo mensaje.
+        const token = process.env.ADA_BROKER_TOKEN?.trim();
+        if (!token) {
+            console.error("Falta ADA_BROKER_TOKEN. El broker no arranca sin un bearer: escuchar sin auth expondría " +
+                "las credenciales de todo el equipo a quien alcance el puerto.\n" +
+                'Genera uno y expórtalo, por ejemplo: export ADA_BROKER_TOKEN="$(node -e \'console.log(require("crypto").randomBytes(24).toString("hex"))\')"');
+            process.exitCode = 1;
+            return true;
+        }
+        const iCredenciales = args.indexOf("--credenciales");
+        const rutaCredenciales = iCredenciales >= 0 ? args[iCredenciales + 1] : undefined;
+        if (!rutaCredenciales) {
+            console.error("Falta --credenciales <archivo.json> con las credenciales del pool. Formato: " +
+                '{"<proveedor>": [{"id": "...", "valor": "..."}, ...]}');
+            process.exitCode = 1;
+            return true;
+        }
+        let credencialesCrudo;
+        try {
+            credencialesCrudo = await readFile(rutaCredenciales, "utf-8");
+        }
+        catch (error) {
+            console.error(`No se puede leer ${rutaCredenciales}: ${error instanceof Error ? error.message : String(error)}`);
+            process.exitCode = 1;
+            return true;
+        }
+        const pool = new CredencialPool(JSON.parse(credencialesCrudo));
+        // Sesión propia "broker": no es una sesión de agente, pero el libro es el
+        // mismo mecanismo y el mismo directorio — es lo que hace auditable "quién
+        // usó qué cuenta y cuándo" sin construir un segundo sistema de registro.
+        const libro = new LibroDeSesion(agentDir, "broker");
+        const iEscuchar = args.indexOf("--escuchar");
+        const bind = iEscuchar >= 0 && args[iEscuchar + 1] ? args[iEscuchar + 1] : DEFAULT_BROKER_BIND;
+        try {
+            const servidor = await iniciarServidorBroker({ pool, token, libro, bind });
+            console.log(`Broker de credenciales escuchando en ${servidor.url}`);
+            console.log("Bearer requerido en cada petición salvo /v1/health. Ctrl-C para parar.");
+            await new Promise(() => { });
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exitCode = 1;
+        }
+        return true;
+    }
+    const socketIndex = args.indexOf("--socket");
+    const { defaultSocketPath } = await import("../server/serve.js");
+    const socketPath = socketIndex >= 0 && args[socketIndex + 1] ? args[socketIndex + 1] : defaultSocketPath(agentDir);
+    if (args[0] === "sessions") {
+        const { SessionManager } = await import("../core/session-manager.js");
+        const sessions = await SessionManager.list(process.cwd());
+        if (sessions.length === 0) {
+            console.log("No hay sesiones en este proyecto.");
+            return true;
+        }
+        for (const session of sessions) {
+            const name = session.name ? ` — ${session.name}` : "";
+            console.log(`${session.id.slice(0, 8)}  ${session.modified.toISOString()}  ${session.messageCount} msgs${name}`);
+        }
+        return true;
+    }
+    if (args[0] === "session") {
+        // `ada-cli session <id> <op> [args]` — compact/rename/fork/kill sobre una
+        // sesión del servidor. Van por el comando genérico `extension`, así que
+        // añadir una op nueva no toca este fichero ni el protocolo.
+        const { sessionId, op, rest } = parseSessionOpArgs(args);
+        if (!sessionId || !op) {
+            console.error("Uso: ada-cli session <id> <compact|rename|fork|kill|ops> [args]");
+            process.exitCode = 1;
+            return true;
+        }
+        const { existsSync } = await import("node:fs");
+        if (!existsSync(socketPath)) {
+            console.error(`No hay ningún servidor de Ada en ${socketPath}. Arráncalo con 'ada-cli serve'.`);
+            process.exitCode = 1;
+            return true;
+        }
+        const payload = op === "rename"
+            ? { name: rest.join(" ") }
+            : op === "compact" && rest.length > 0
+                ? { customInstructions: rest.join(" ") }
+                : {};
+        const { runExtensionOp } = await import("../server/extension-ops.js");
+        const result = await runExtensionOp({ socketPath, op, sessionId, payload });
+        if (!result.ok) {
+            console.error(result.error ?? "la operación falló");
+            process.exitCode = 1;
+            return true;
+        }
+        console.log(JSON.stringify(result.data, null, 2));
+        return true;
+    }
+    if (args[0] === "attach") {
+        const sessionId = args[1];
+        if (!sessionId) {
+            console.error("Falta el id de sesión. Usa 'ada-cli sessions' para verlos.");
+            process.exitCode = 1;
+            return true;
+        }
+        const { existsSync } = await import("node:fs");
+        if (!existsSync(socketPath)) {
+            console.error(`No hay ningún servidor de Ada en ${socketPath}. Arráncalo con 'ada-cli serve'.`);
+            process.exitCode = 1;
+            return true;
+        }
+        const { attach } = await import("../server/attach.js");
+        try {
+            // --watch: solo mirar, sin abrir entrada. Útil para vigilar un goal
+            // largo sin riesgo de escribir en él por accidente.
+            await attach({ socketPath, sessionId, readOnly: args.includes("--watch") });
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exitCode = 1;
+        }
+        return true;
+    }
+    // serve
+    const { AdaServerService } = await import("../server/pi-server-service.js");
+    const { serve } = await import("../server/serve.js");
+    const { createAgentSession } = await import("../core/sdk.js");
+    const service = new AdaServerService({
+        agentDir,
+        defaultCwd: process.cwd(),
+        createSession: async (options) => {
+            const { session } = await createAgentSession({
+                cwd: options.cwd,
+                agentDir,
+                sessionManager: options.sessionManager,
+            });
+            return session;
+        },
+    });
+    try {
+        const handle = await serve({
+            service,
+            socketPath,
+            onError: (error) => console.error(`[serve] ${error.message}`),
+        });
+        // Reloj del scheduler: los trabajos recurrentes solo existen mientras haya
+        // un proceso vivo que los dispare, y ese proceso es este.
+        const { Scheduler } = await import("../core/scheduler/scheduler.js");
+        const { startSchedulerTick } = await import("../server/scheduler-tick.js");
+        const scheduler = new Scheduler(agentDir);
+        startSchedulerTick({
+            scheduler,
+            onError: (error) => console.error(`[schedule] ${error.message}`),
+            dispatch: async (job) => {
+                // Sesión propia por job: dos trabajos recurrentes compartiendo
+                // historial se contaminarían el contexto mutuamente.
+                const runtime = await service.createSession({ id: `schedule-${job.id}-${Date.now()}`, cwd: process.cwd() });
+                await runtime.prompt({ text: job.prompt });
+                return true;
+            },
+        });
+        console.log(`Ada escuchando en ${handle.socketPath}`);
+        console.log("El trabajo continúa aunque cierres este terminal. Ctrl-C para parar el servidor.");
+        // Mantener vivo el proceso: el servidor es el dueño de la ejecución.
+        await new Promise(() => { });
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    }
+    return true;
+}
+//# sourceMappingURL=serve-command.js.map