mcp-phase-gate 2.1.0 → 2.2.0

package/build/phases.js

@@ -4,9 +4,37 @@
 import * as fs from "fs";
 import * as path from "path";
 import { promptsLayers } from "./config.js";
+import { log } from "./log.js";
 import { claveDeNombre, validarSegmento } from "./paths.js";
 // Las reglas globales se anteponen a cada fase.
-const GLOBAL_RULES_FILE = "global-rules.md";
+export const GLOBAL_RULES_FILE = "global-rules.md";
+// Comando de cada fase (`/fN`): `comandos/fN.md` dentro de una capa de prompts. Gana la capa más
+// alta que lo tenga, igual que las fases; sin ninguno, la fase usa un texto genérico.
+export const CARPETA_COMANDOS = "comandos";
+export function resolveCommandFile(numero, capas = promptsLayers()) {
+    for (const base of [...capas].reverse()) {
+        const ruta = path.join(base, CARPETA_COMANDOS, `f${numero}.md`);
+        if (tipoDe(ruta) === "archivo")
+            return ruta;
+    }
+    return null;
+}
+// statSync con throwIfNoEntry solo calla el ENOENT: si un tramo de la ruta es un archivo
+// (ENOTDIR) o no hay permiso, lanza igual. Para preguntar "¿es una carpeta?" eso no es un error.
+function tipoDe(ruta) {
+    try {
+        const info = fs.statSync(ruta, { throwIfNoEntry: false });
+        if (!info)
+            return null;
+        return info.isDirectory() ? "carpeta" : info.isFile() ? "archivo" : "otro";
+    }
+    catch {
+        return null;
+    }
+}
+export function esCarpeta(ruta) {
+    return tipoDe(ruta) === "carpeta";
+}
 // Acepta "fase-1-descubrimiento.md" y también "phase-1-discovery.md",
 // para que un juego de prompts en inglés funcione sin tocar el código.
 export const PHASE_FILE_PATTERN = /^(?:fase|phase)-(\d+)[-.]/i;
@@ -20,7 +48,7 @@ const PHASE_FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
 // tests va siempre en LF y sin BOM. Con el BOM delante, el frontmatter no se reconocía y la fase
 // se quedaba sin documento.
 function aLF(texto) {
-    return texto.replace(/^/, "").replace(/\r\n/g, "\n");
+    return texto.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n");
 }
 // Quita los marcadores de ranura y conserva su contenido. El modelo nunca los ve.
 // Una ranura marca el contenido de una sección que un preset podrá sustituir en la Etapa 3:
@@ -39,7 +67,7 @@ const RESTO_DE_MARCADOR = /<!--[^\n]*?ranura/i;
 function entregable(texto, archivo) {
     const limpio = quitarMarcadores(texto);
     if (RESTO_DE_MARCADOR.test(limpio)) {
-        console.error(`[orquestador] ${archivo} tiene un marcador de ranura que no se reconoce: llega tal cual al modelo.`);
+        log("warning", `${archivo} tiene un marcador de ranura que no se reconoce: llega tal cual al modelo.`);
     }
     return limpio.trim();
 }
@@ -56,7 +84,7 @@ function leerRecibos(valor, archivo) {
         return segmento;
     }
     catch (error) {
-        console.error(`[orquestador] Se ignora el frontmatter recibos de ${archivo}: ${error.message}`);
+        log("warning", `Se ignora el frontmatter recibos de ${archivo}: ${error.message}`);
         return undefined;
     }
 }
@@ -73,14 +101,19 @@ function descartarRecibosQueChocan(phases) {
     }
     for (const datos of phases.values()) {
         if (datos.recibos && documentos.has(claveDeNombre(datos.recibos))) {
-            console.error(`[orquestador] Se ignora el frontmatter recibos de ${datos.file}: ` +
+            log("warning", `Se ignora el frontmatter recibos de ${datos.file}: ` +
                 `"${datos.recibos}" es el nombre de un documento de fase.`);
             datos.recibos = undefined;
         }
     }
 }
 export function parsePhaseFile(fullPath) {
-    const crudo = aLF(fs.readFileSync(fullPath, "utf-8"));
+    return separarFrontmatter(fs.readFileSync(fullPath, "utf-8"));
+}
+// La cabecera "clave: valor" de un texto ya leído, y el resto. Sirve igual para un prompt que
+// para un recibo de lote, que usan el mismo formato.
+export function separarFrontmatter(texto) {
+    const crudo = aLF(texto);
     const encontrada = crudo.match(PHASE_FRONTMATTER);
     if (!encontrada)
         return { meta: {}, cuerpo: crudo };
@@ -109,7 +142,9 @@ export function parsePhaseFile(fullPath) {
 export function discoverPhases(capas = promptsLayers()) {
     const phases = new Map();
     for (const base of capas) {
-        if (!fs.existsSync(base))
+        // Una capa que no existe o que no es una carpeta (PHASE_GATE_PROMPTS_PATH apuntando a un
+        // archivo) se salta: doctor la avisa, y las fases de las demás capas siguen sirviendo.
+        if (!esCarpeta(base))
             continue;
         // Se resuelve capa por capa: dentro de una, gana el primero por orden alfabético; entre
         // capas, gana la de más arriba. Sin este mapa intermedio la regla alfabética de la capa
@@ -186,7 +221,7 @@ export function loadPhasePrompt(phase, capas = promptsLayers()) {
 // fábrica, no se suman: concatenar dos juegos de reglas hace imposible saber de qué archivo
 // salió la instrucción que estorbó cuando algo sale raro, que es justo el momento en que hay
 // que saberlo. Si quieres las de fábrica y algo más, las copias y añades.
-function resolveGlobalRules(capas) {
+export function resolveGlobalRules(capas = promptsLayers()) {
     for (const base of [...capas].reverse()) {
         const ruta = path.join(base, GLOBAL_RULES_FILE);
         if (fs.existsSync(ruta))
@@ -194,6 +229,11 @@ function resolveGlobalRules(capas) {
     }
     return null;
 }
+// El texto de un prompt propio tal como lo ve el modelo: en LF y sin BOM. Lo usan quienes leen
+// un archivo de prompts fuera de este módulo, como el diagnóstico.
+export function leerPromptNormalizado(ruta) {
+    return aLF(fs.readFileSync(ruta, "utf-8"));
+}
 // Bloque que se añade al final del prompt con los nombres exactos de los documentos: el que
 // produce esta fase y los de las anteriores, que son los que hay que leer, y la subcarpeta de
 // recibos de la fase que la declare. Va aquí y no en el
@@ -229,13 +269,4 @@ export function describePhaseFiles(available, phase) {
     }
     return lineas.join("\n");
 }
-export function describePhases() {
-    const available = discoverPhases();
-    if (available.size === 0)
-        return "No se encontraron prompts de fase.";
-    return [...available.entries()]
-        .sort((a, b) => a[0] - b[0])
-        .map(([number, { title }]) => `${number}: ${title}`)
-        .join(", ");
-}
 //# sourceMappingURL=phases.js.map

package/build/prompts-mcp.d.ts

@@ -0,0 +1,33 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+export declare function argumentosDeFase(numero: number): {
+    project: z.ZodOptional<z.ZodString>;
+    task_name: z.ZodOptional<z.ZodString>;
+    contexto: z.ZodOptional<z.ZodString>;
+    commits?: never;
+} | {
+    project: z.ZodOptional<z.ZodString>;
+    commits: z.ZodOptional<z.ZodString>;
+    task_name?: never;
+    contexto?: never;
+} | {
+    project: z.ZodOptional<z.ZodString>;
+    task_name?: never;
+    contexto?: never;
+    commits?: never;
+};
+export declare function tituloDePrompt(numero: number, titulo: string): string;
+export declare function descripcionDePrompt(numero: number, titulo: string): string;
+export declare function textoGenerico(numero: number, titulo: string): string;
+type Argumentos = {
+    project?: string | undefined;
+    task_name?: string | undefined;
+    commits?: string | undefined;
+    contexto?: string | undefined;
+};
+export declare function textoDelComando(numero: number, titulo: string, args: Argumentos, capas?: string[]): string;
+export declare function sincronizarPrompts(mcp: McpServer): void;
+export declare function asegurarCapacidadDePrompts(mcp: McpServer): void;
+export declare function vigilarCapas(mcp: McpServer, esperaMs?: number): () => void;
+export {};
+//# sourceMappingURL=prompts-mcp.d.ts.map

package/build/prompts-mcp.js

@@ -0,0 +1,194 @@
+// Los comandos de fase (/f1…/fN) servidos como MCP Prompts. Antes había que copiar cada comando a
+// mano en la carpeta de cada cliente y de cada equipo, y las copias se desincronizaban; ahora el
+// servidor los ofrece a cualquier cliente que muestre prompts, y llegan con cada versión.
+//
+// El texto de cada comando vive en `comandos/fN.md` dentro de una capa de prompts (los de fábrica
+// en prompts/comandos/), y se resuelve por capas como las fases: gana la más alta que lo tenga.
+// Una fase sin comando, como una fase-6 propia, recibe un texto genérico que funciona igual.
+//
+// El prompt NO incluye el prompt de la fase: sigue siendo orquestación ("llama a
+// get_phase_prompt(N)…"). Devolver ya el texto de la fase ahorraría una llamada, pero crearía dos
+// caminos para recibir el mismo prompt, y en uno la compuerta no recibiría el `project`.
+import * as fs from "fs";
+import { z } from "zod";
+import { promptsLayers } from "./config.js";
+import { log } from "./log.js";
+import { discoverPhases, parsePhaseFile, resolveCommandFile } from "./phases.js";
+// Todos los argumentos son opcionales: el texto de cada comando ya pide lo que falte, y así el
+// prompt sirve también en clientes que parten los argumentos por espacios (un contexto largo puede
+// ir pegado después del comando, como texto normal del chat).
+const PROJECT = z.string().optional().describe("Proyecto en el que estás trabajando.");
+export function argumentosDeFase(numero) {
+    if (numero === 1) {
+        return {
+            project: PROJECT,
+            task_name: z.string().optional().describe("Nombre corto de la tarea nueva."),
+            contexto: z.string().optional().describe("El correo, mensaje o requerimiento completo."),
+        };
+    }
+    if (numero === 5) {
+        return {
+            project: PROJECT,
+            commits: z
+                .string()
+                .optional()
+                .describe("Rango de commits a auditar. Si lo omites, se toman de los recibos de la Fase 4."),
+        };
+    }
+    return { project: PROJECT };
+}
+export function tituloDePrompt(numero, titulo) {
+    return `Fase ${numero} · ${titulo}`;
+}
+export function descripcionDePrompt(numero, titulo) {
+    return `Arranca la Fase ${numero} (${titulo}) del flujo de mcp-phase-gate.`;
+}
+export function textoGenerico(numero, titulo) {
+    return [
+        `Vas a iniciar la FASE ${numero} (${titulo}) del flujo del mcp-phase-gate.`,
+        "",
+        "Pasos:",
+        "1. Si no sabes cuál es la tarea activa, llama a `get_active_task` (o pídeme project + task_name).",
+        `2. Llama a \`get_phase_prompt(${numero})\` indicándole también el \`project\` en el que estoy trabajando, y asume ese rol.`,
+        "3. Lee los documentos de las fases anteriores con `read_central_doc`; `get_phase_prompt` te dio sus nombres exactos.",
+        "4. Sigue el prompt de la fase y guarda su documento con `write_central_doc`, con el nombre que te indicó `get_phase_prompt`.",
+    ].join("\n");
+}
+// La sección con lo que vino como argumento. Solo aparecen las líneas de los que vinieron, y sin
+// ninguno la sección no existe: así el texto queda igual que el comando escrito a mano.
+function datosDeInvocacion(args) {
+    const presente = (valor) => typeof valor === "string" && valor.trim() !== "";
+    const lineas = [];
+    // project, task_name y commits son de una línea: los saltos se aplanan, para que un valor no
+    // pueda abrir secciones nuevas dentro del texto. El contexto sí es multilínea por naturaleza, y
+    // va tal cual: lo escribe la persona, igual que si lo pegara en el chat.
+    const enUnaLinea = (valor) => valor.replace(/\s+/g, " ").trim();
+    if (presente(args.project))
+        lineas.push(`- project: ${enUnaLinea(args.project)}`);
+    if (presente(args.task_name))
+        lineas.push(`- task_name: ${enUnaLinea(args.task_name)}`);
+    if (presente(args.commits))
+        lineas.push(`- commits: ${enUnaLinea(args.commits)}`);
+    if (presente(args.contexto))
+        lineas.push("- initial_context:", "", args.contexto.trim());
+    return lineas.length ? ["## Datos de esta invocación", ...lineas].join("\n") : null;
+}
+// El texto se lee en cada llamada, como los prompts de fase: editar un comando no exige reiniciar.
+export function textoDelComando(numero, titulo, args, capas = promptsLayers()) {
+    const archivo = resolveCommandFile(numero, capas);
+    let cuerpo;
+    if (archivo) {
+        try {
+            cuerpo = parsePhaseFile(archivo).cuerpo.trim();
+        }
+        catch (error) {
+            log("warning", `No se pudo leer ${archivo}; se usa el texto genérico: ${error instanceof Error ? error.message : String(error)}`);
+            cuerpo = textoGenerico(numero, titulo);
+        }
+    }
+    else {
+        cuerpo = textoGenerico(numero, titulo);
+    }
+    const datos = datosDeInvocacion(args);
+    return datos ? `${cuerpo}\n\n${datos}` : cuerpo;
+}
+const registros = new WeakMap();
+function registrar(mcp, numero, titulo) {
+    return mcp.registerPrompt(`f${numero}`, {
+        title: tituloDePrompt(numero, titulo),
+        description: descripcionDePrompt(numero, titulo),
+        argsSchema: argumentosDeFase(numero),
+    }, async (args) => {
+        // El título se toma del registro vigente: puede haber cambiado desde que se registró.
+        const vigente = registros.get(mcp)?.get(numero)?.titulo ?? titulo;
+        return {
+            description: descripcionDePrompt(numero, vigente),
+            messages: [{ role: "user", content: { type: "text", text: textoDelComando(numero, vigente, args) } }],
+        };
+    });
+}
+// Nunca lanza: se llama tras cada tool, y un prompt que no se pudo registrar no debe convertir en
+// error la respuesta de una tool que salió bien.
+export function sincronizarPrompts(mcp) {
+    try {
+        const capas = promptsLayers();
+        const fases = discoverPhases(capas);
+        let actuales = registros.get(mcp);
+        if (!actuales) {
+            actuales = new Map();
+            registros.set(mcp, actuales);
+        }
+        for (const [numero, registro] of [...actuales]) {
+            if (!fases.has(numero)) {
+                registro.prompt.remove();
+                actuales.delete(numero);
+            }
+        }
+        for (const [numero, datos] of fases) {
+            const comando = resolveCommandFile(numero, capas);
+            const registro = actuales.get(numero);
+            if (!registro) {
+                actuales.set(numero, { prompt: registrar(mcp, numero, datos.title), titulo: datos.title, comando });
+                continue;
+            }
+            if (registro.titulo !== datos.title || registro.comando !== comando) {
+                registro.titulo = datos.title;
+                registro.comando = comando;
+                registro.prompt.update({
+                    title: tituloDePrompt(numero, datos.title),
+                    description: descripcionDePrompt(numero, datos.title),
+                });
+            }
+        }
+    }
+    catch (error) {
+        log("warning", `No se pudieron sincronizar los prompts /fN: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+// La capacidad `prompts` solo se puede declarar antes de conectar. Si al arrancar no hay ninguna
+// fase (una carpeta de prompts vacía o mal configurada), el primer /fN que apareciera después
+// intentaría declararla con la conexión abierta y el SDK lo rechazaría. Registrar y quitar un
+// prompt de paso deja la capacidad declarada sin que la lista tenga nada.
+export function asegurarCapacidadDePrompts(mcp) {
+    if ((registros.get(mcp)?.size ?? 0) > 0)
+        return;
+    // Un nombre que ninguna fase puede tener: las fases se registran como f<número>.
+    mcp.registerPrompt("phase-gate-provisional", { description: "provisional" }, async () => ({ messages: [] })).remove();
+}
+// ─── Vigilancia de las capas ────────────────────────────────────────────────
+// Mejora oportunista: con fs.watch, un comando o una fase nueva aparece sin esperar a la siguiente
+// llamada a una tool. En OneDrive y en algunas unidades de red fs.watch no avisa, y por eso lo que
+// garantiza el resultado es la sincronización tras cada tool, no esto. Los vigilantes no mantienen
+// vivo el proceso (unref) y se cierran con el servidor.
+export function vigilarCapas(mcp, esperaMs = 300) {
+    const vigilantes = [];
+    let temporizador = null;
+    const programar = () => {
+        if (temporizador)
+            clearTimeout(temporizador);
+        temporizador = setTimeout(() => {
+            temporizador = null;
+            sincronizarPrompts(mcp);
+        }, esperaMs);
+        temporizador.unref();
+    };
+    for (const capa of promptsLayers()) {
+        if (!fs.statSync(capa, { throwIfNoEntry: false })?.isDirectory())
+            continue;
+        try {
+            const vigilante = fs.watch(capa, { recursive: true, persistent: false }, programar);
+            vigilante.on("error", () => vigilante.close());
+            vigilantes.push(vigilante);
+        }
+        catch {
+            // Sin vigilancia en esta capa: la sincronización tras cada tool sigue cubriéndola.
+        }
+    }
+    return () => {
+        if (temporizador)
+            clearTimeout(temporizador);
+        for (const vigilante of vigilantes)
+            vigilante.close();
+    };
+}
+//# sourceMappingURL=prompts-mcp.js.map

package/build/recursos.d.ts

@@ -0,0 +1,8 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare const URI_ESTADO = "phase-gate://estado";
+export declare const URI_FASES = "phase-gate://fases";
+export declare function uriDeDocumento(proyecto: string, tarea: string, documento: string): string;
+export declare function uriDeRecibo(proyecto: string, tarea: string, recibo: string): string;
+export declare function tablaDeFases(): string;
+export declare function registrarRecursos(mcp: McpServer): void;
+//# sourceMappingURL=recursos.d.ts.map

package/build/recursos.js

@@ -0,0 +1,306 @@
+// Los documentos de las tareas, expuestos como MCP Resources de solo lectura. Un cliente que los
+// muestra (con "@" en Claude Code, Cursor o VS Code) deja a la persona adjuntar al chat el plan
+// técnico o un recibo sin pedírselo al modelo, y al modelo leerlos sin gastar una llamada a
+// read_central_doc.
+//
+//   phase-gate://estado                                     el diagnóstico de la instalación
+//   phase-gate://fases                                      las fases, con su documento y su capa
+//   phase-gate://tareas/{proyecto}/{tarea}/{documento}      un archivo de la carpeta de una tarea
+//   phase-gate://tareas/{proyecto}/{tarea}/recibos/{recibo} un recibo de lote de la Fase 4
+//
+// Solo lectura, y con las mismas defensas que read_central_doc: cada variable se decodifica y se
+// valida como un segmento portable antes de armar ninguna ruta, la ruta final tiene que quedar
+// dentro de la carpeta de la tarea, y la lectura está acotada a 1 MB de texto.
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ErrorCode, McpError } from "@modelcontextprotocol/sdk/types.js";
+import * as fs from "fs";
+import * as path from "path";
+import { diagnosticar, fasesConCapa, formatearDiagnostico } from "./diagnostico.js";
+import { discoverProjects, estaDentroReal, findProjectFolder, leerTextoAcotado, requireProjectFolder, taskFolderPath, validarSegmento, } from "./paths.js";
+import { discoverPhases, esCarpeta, nombreContextoInicial } from "./phases.js";
+import { listarTareas, tareaActiva } from "./tasks.js";
+export const URI_ESTADO = "phase-gate://estado";
+export const URI_FASES = "phase-gate://fases";
+const MIME = "text/markdown";
+const AUDIENCIA = ["assistant", "user"];
+export function uriDeDocumento(proyecto, tarea, documento) {
+    return `phase-gate://tareas/${encodeURIComponent(proyecto)}/${encodeURIComponent(tarea)}/${encodeURIComponent(documento)}`;
+}
+export function uriDeRecibo(proyecto, tarea, recibo) {
+    return `phase-gate://tareas/${encodeURIComponent(proyecto)}/${encodeURIComponent(tarea)}/recibos/${encodeURIComponent(recibo)}`;
+}
+// La subcarpeta de recibos la declara una fase en su cabecera (con los prompts de fábrica, la 4).
+function subcarpetaDeRecibos(phases) {
+    const conRecibos = [...phases.entries()].sort((a, b) => a[0] - b[0]).find(([, datos]) => datos.recibos);
+    return conRecibos?.[1].recibos ?? null;
+}
+// statSync con throwIfNoEntry solo calla el ENOENT; un tramo de la ruta que es un archivo
+// (ENOTDIR) o un permiso denegado no son un error para preguntar "¿es un archivo?".
+function esArchivo(ruta) {
+    try {
+        return fs.statSync(ruta, { throwIfNoEntry: false })?.isFile() ?? false;
+    }
+    catch {
+        return false;
+    }
+}
+// Lo que se lista o se autocompleta pasa por la misma contención que la lectura: un enlace dentro
+// de la tarea que lleva fuera de ella no se lee, y tampoco se enseña su nombre ni su fecha.
+function dentroDeLaTarea(carpetaTarea, ruta) {
+    try {
+        return estaDentroReal(carpetaTarea, ruta);
+    }
+    catch {
+        return false;
+    }
+}
+// Los errores de lectura llegan al cliente con un código que dice qué pasó, no como un error
+// interno: -32002 si el recurso no existe (el que propone la especificación de MCP), -32602 si el
+// URI o lo que apunta no es válido, y -32603 solo para un fallo de E/S inesperado.
+const RECURSO_NO_ENCONTRADO = -32002;
+function conCodigo(leerRecurso) {
+    try {
+        return leerRecurso();
+    }
+    catch (error) {
+        if (error instanceof McpError)
+            throw error;
+        const mensaje = error instanceof Error ? error.message : String(error);
+        if (/^No existe/.test(mensaje))
+            throw new McpError(RECURSO_NO_ENCONTRADO, mensaje);
+        if (typeof error?.code === "string")
+            throw new McpError(ErrorCode.InternalError, mensaje);
+        throw new McpError(ErrorCode.InvalidParams, mensaje);
+    }
+}
+// El SDK entrega las variables tal como venían en el URI, con su codificación porcentual. Se
+// decodifican aquí y se validan DESPUÉS: un %2F decodificado a "/" lo rechaza validarSegmento.
+function variable(variables, nombre) {
+    const crudo = variables[nombre];
+    const valor = Array.isArray(crudo) ? crudo.join(",") : String(crudo ?? "");
+    try {
+        return decodeURIComponent(valor);
+    }
+    catch {
+        throw new Error(`URI mal codificada: la parte "${nombre}" (${valor}) no es una codificación porcentual válida.`);
+    }
+}
+// Ruta de un archivo dentro de una tarea, a partir de las variables ya decodificadas. Las carpetas
+// y archivos con punto no son tareas ni documentos, igual que para write_central_doc.
+function archivoDeTarea(proyecto, tarea, partes) {
+    validarSegmento(proyecto, "proyecto");
+    validarSegmento(tarea, "tarea");
+    for (const parte of partes)
+        validarSegmento(parte, "documento");
+    if (tarea.startsWith(".") || partes.some((parte) => parte.startsWith("."))) {
+        throw new Error("Los archivos y carpetas que empiezan por punto no se exponen como recursos.");
+    }
+    const carpetaProyecto = requireProjectFolder(proyecto);
+    const carpetaTarea = taskFolderPath(carpetaProyecto, tarea);
+    if (!esCarpeta(carpetaTarea)) {
+        throw new Error(`No existe la tarea "${tarea}" en ${carpetaProyecto}.`);
+    }
+    const ruta = path.join(carpetaTarea, ...partes);
+    if (!estaDentroReal(carpetaTarea, ruta)) {
+        throw new Error(`Acceso denegado: el recurso queda fuera de la carpeta de la tarea ${carpetaTarea}.`);
+    }
+    if (!esArchivo(ruta)) {
+        throw new Error(`No existe "${partes.join("/")}" en la tarea "${tarea}" de ${carpetaProyecto}.`);
+    }
+    return { ruta, tarea: carpetaTarea };
+}
+function leer(uri, ruta) {
+    return { contents: [{ uri: uri.href, mimeType: MIME, text: leerTextoAcotado(ruta) }] };
+}
+function recurso(uri, nombre, titulo, ruta) {
+    let modificado;
+    try {
+        modificado = fs.statSync(ruta).mtime.toISOString();
+    }
+    catch {
+        modificado = undefined;
+    }
+    return {
+        uri,
+        name: nombre,
+        title: titulo,
+        mimeType: MIME,
+        annotations: { audience: AUDIENCIA, ...(modificado ? { lastModified: modificado } : {}) },
+    };
+}
+// ─── Listado ────────────────────────────────────────────────────────────────
+// Solo los documentos que existen de la tarea ACTIVA de cada proyecto. Listar todas las tareas de
+// todos los proyectos inundaría el selector de "@" del cliente; el resto se alcanza por plantilla,
+// con autocompletado. Si la Documentación no está configurada no hay nada que listar, y el listado
+// no debe fallar por eso: los recursos fijos siguen sirviendo para diagnosticarlo.
+function tareasActivas() {
+    try {
+        const phases = discoverPhases();
+        return [...discoverProjects().values()].sort().flatMap((proyecto) => {
+            const activa = tareaActiva(proyecto, phases);
+            return activa ? [{ proyecto, tarea: activa.estado.taskName, carpeta: activa.estado.folderPath, phases }] : [];
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function listarDocumentos() {
+    const lista = [];
+    for (const { proyecto, tarea, carpeta, phases } of tareasActivas()) {
+        const nombres = [
+            nombreContextoInicial(),
+            ...[...phases.entries()].sort((a, b) => a[0] - b[0]).flatMap(([, datos]) => (datos.documento ? [datos.documento] : [])),
+        ];
+        for (const documento of nombres) {
+            const ruta = path.join(carpeta, documento);
+            if (!esArchivo(ruta) || !dentroDeLaTarea(carpeta, ruta))
+                continue;
+            lista.push(recurso(uriDeDocumento(proyecto, tarea, documento), `${proyecto}/${tarea}/${documento}`, `${tarea} · ${documento}`, ruta));
+        }
+    }
+    return lista;
+}
+function recibosDe(carpetaTarea, phases) {
+    const subcarpeta = subcarpetaDeRecibos(phases);
+    if (!subcarpeta)
+        return [];
+    const carpeta = path.join(carpetaTarea, subcarpeta);
+    if (!esCarpeta(carpeta) || !dentroDeLaTarea(carpetaTarea, carpeta))
+        return [];
+    return fs
+        .readdirSync(carpeta, { withFileTypes: true })
+        .filter((entrada) => entrada.isFile() && entrada.name.toLowerCase().endsWith(".md") && !entrada.name.startsWith("."))
+        .map((entrada) => entrada.name)
+        .filter((nombre) => dentroDeLaTarea(carpetaTarea, path.join(carpeta, nombre)))
+        .sort();
+}
+function listarRecibos() {
+    const lista = [];
+    for (const { proyecto, tarea, carpeta, phases } of tareasActivas()) {
+        const subcarpeta = subcarpetaDeRecibos(phases);
+        for (const recibo of recibosDe(carpeta, phases)) {
+            lista.push(recurso(uriDeRecibo(proyecto, tarea, recibo), `${proyecto}/${tarea}/${subcarpeta}/${recibo}`, `${tarea} · ${recibo}`, path.join(carpeta, subcarpeta, recibo)));
+        }
+    }
+    return lista;
+}
+// ─── Autocompletado ─────────────────────────────────────────────────────────
+// Lo que ya se escribió filtra la lista, sin distinguir mayúsculas. Un fallo (Documentación sin
+// configurar, proyecto que no existe) devuelve una lista vacía: autocompletar no es el sitio
+// para explicar errores, eso lo hace la lectura.
+function filtrar(valores, escrito) {
+    const prefijo = escrito.toLowerCase();
+    return valores.filter((valor) => valor.toLowerCase().startsWith(prefijo));
+}
+function sinFallar(calcular) {
+    try {
+        return calcular();
+    }
+    catch {
+        return [];
+    }
+}
+function completarProyecto(escrito) {
+    return sinFallar(() => filtrar([...discoverProjects().values()].sort(), escrito));
+}
+function completarTarea(escrito, contexto) {
+    return sinFallar(() => {
+        const proyecto = findProjectFolder(contexto?.arguments?.proyecto ?? "");
+        if (!proyecto)
+            return [];
+        return filtrar(listarTareas(proyecto, discoverPhases()).map((tarea) => tarea.taskName), escrito);
+    });
+}
+function carpetaDeTareaPedida(contexto) {
+    const proyecto = findProjectFolder(contexto?.arguments?.proyecto ?? "");
+    const tarea = contexto?.arguments?.tarea ?? "";
+    if (!proyecto || !tarea || tarea.startsWith("."))
+        return null;
+    validarSegmento(tarea, "tarea");
+    const carpeta = taskFolderPath(proyecto, tarea);
+    return esCarpeta(carpeta) ? carpeta : null;
+}
+function completarDocumento(escrito, contexto) {
+    return sinFallar(() => {
+        const carpeta = carpetaDeTareaPedida(contexto);
+        if (!carpeta)
+            return [];
+        const documentos = fs
+            .readdirSync(carpeta, { withFileTypes: true })
+            .filter((entrada) => entrada.isFile() && entrada.name.toLowerCase().endsWith(".md") && !entrada.name.startsWith("."))
+            .map((entrada) => entrada.name)
+            .filter((nombre) => dentroDeLaTarea(carpeta, path.join(carpeta, nombre)))
+            .sort();
+        return filtrar(documentos, escrito);
+    });
+}
+function completarRecibo(escrito, contexto) {
+    return sinFallar(() => {
+        const carpeta = carpetaDeTareaPedida(contexto);
+        return carpeta ? filtrar(recibosDe(carpeta, discoverPhases()), escrito) : [];
+    });
+}
+// ─── La tabla de fases ──────────────────────────────────────────────────────
+function celda(texto) {
+    return texto.replace(/\r?\n/g, " ").replace(/\|/g, "\\|");
+}
+export function tablaDeFases() {
+    const fases = fasesConCapa();
+    if (fases.length === 0)
+        return "No se encontró ningún prompt de fase.";
+    return [
+        "| Fase | Título | Documento | Recibos | Capa | Archivo |",
+        "|---|---|---|---|---|---|",
+        ...fases.map((fase) => `| ${fase.numero} | ${celda(fase.titulo)} | ${fase.documento ? `\`${celda(fase.documento)}\`` : "—"} | ` +
+            `${fase.recibos ? `\`${celda(fase.recibos)}/\`` : "—"} | ${fase.capa} | \`${celda(fase.archivo)}\` |`),
+    ].join("\n");
+}
+// ─── Registro ───────────────────────────────────────────────────────────────
+export function registrarRecursos(mcp) {
+    mcp.registerResource("estado", URI_ESTADO, {
+        title: "Estado de mcp-phase-gate",
+        description: "Radiografía de la instalación: variables, prompts, proyectos con su tarea activa y avisos.",
+        mimeType: MIME,
+        annotations: { audience: AUDIENCIA },
+    }, async (uri) => ({ contents: [{ uri: uri.href, mimeType: MIME, text: formatearDiagnostico(diagnosticar(), "markdown") }] }));
+    mcp.registerResource("fases", URI_FASES, {
+        title: "Fases disponibles",
+        description: "Número, título, documento, subcarpeta de recibos y archivo de prompt que gana en cada fase.",
+        mimeType: MIME,
+        annotations: { audience: AUDIENCIA },
+    }, async (uri) => ({ contents: [{ uri: uri.href, mimeType: MIME, text: tablaDeFases() }] }));
+    // El de recibos va antes que el de documentos: los dos empiezan igual, y el SDK usa la primera
+    // plantilla que encaja. Con variables que no cruzan "/" no se pisan, pero el orden lo deja claro.
+    mcp.registerResource("recibo", new ResourceTemplate("phase-gate://tareas/{proyecto}/{tarea}/recibos/{recibo}", {
+        list: async () => ({ resources: listarRecibos() }),
+        complete: { proyecto: completarProyecto, tarea: completarTarea, recibo: completarRecibo },
+    }), {
+        title: "Recibo de lote",
+        description: "Un recibo de lote de la Fase 4, en la subcarpeta que declara su prompt.",
+        mimeType: MIME,
+    }, async (uri, variables) => conCodigo(() => {
+        const subcarpeta = subcarpetaDeRecibos(discoverPhases());
+        if (!subcarpeta)
+            throw new Error("No existe ninguna fase que declare una subcarpeta de recibos.");
+        const { ruta } = archivoDeTarea(variable(variables, "proyecto"), variable(variables, "tarea"), [
+            subcarpeta,
+            variable(variables, "recibo"),
+        ]);
+        return leer(uri, ruta);
+    }));
+    mcp.registerResource("documento", new ResourceTemplate("phase-gate://tareas/{proyecto}/{tarea}/{documento}", {
+        list: async () => ({ resources: listarDocumentos() }),
+        complete: { proyecto: completarProyecto, tarea: completarTarea, documento: completarDocumento },
+    }), {
+        title: "Documento de una tarea",
+        description: "Un archivo de la carpeta de una tarea: el contexto inicial o el documento de una fase.",
+        mimeType: MIME,
+    }, async (uri, variables) => conCodigo(() => {
+        const { ruta } = archivoDeTarea(variable(variables, "proyecto"), variable(variables, "tarea"), [
+            variable(variables, "documento"),
+        ]);
+        return leer(uri, ruta);
+    }));
+}
+//# sourceMappingURL=recursos.js.map