vipcode 0.0.0-stage → 0.2.0

package/dist/agent.js

@@ -0,0 +1,502 @@
+import { subagents, toolEnabled } from "./agents.js";
+import { systemPrompt } from "./prompt.js";
+import { estimateTokens } from "./router.js";
+import { saveSession } from "./session.js";
+import { skillTool } from "./skills.js";
+import { CORE_TOOLS, beginTurn, describeCall, expandMentions, runTool, taskTool, toolDefinitions, truncate, undoLastTurn, } from "./tools.js";
+const COMPACT_PROMPT = `Summarize this conversation so another engineer can continue the work without the history.
+Include: the user's goal, decisions taken, files read or modified (with paths), the current state and pending steps.
+Be concrete and complete but brief. Write it in the language of the conversation.`;
+export class Agent {
+    deps;
+    session;
+    agent;
+    events = {};
+    // Mensajes que escribes mientras trabaja: se le entregan en cuanto acaba el paso actual
+    queue = [];
+    // Ficheros leídos y cuándo (para no editar a ciegas)
+    readTimes = new Map();
+    lastSlot = "";
+    // Tokens de la última petición (los que dice el proveedor o los estimados)
+    lastTokens = 0;
+    running = false;
+    // Aviso para el modelo que se añade al siguiente mensaje (por ejemplo tras /undo)
+    pendingNote = "";
+    constructor(deps, session, agentName = "build") {
+        this.deps = deps;
+        this.session = session;
+        this.agent = deps.agents.find((agent) => agent.name === agentName) || deps.agents.find((agent) => agent.name === "build");
+    }
+    get mode() {
+        if (this.agent.readOnly) {
+            return "plan";
+        }
+        return "build";
+    }
+    setAgent(name) {
+        const found = this.deps.agents.find((agent) => agent.name === name);
+        if (!found) {
+            return false;
+        }
+        this.agent = found;
+        return true;
+    }
+    updateDeps(changes) {
+        Object.assign(this.deps, changes);
+        const current = this.deps.agents.find((agent) => agent.name === this.agent.name);
+        if (current) {
+            this.agent = current;
+        }
+    }
+    setSession(session) {
+        this.session = session;
+        this.readTimes.clear();
+        this.pendingNote = "";
+        this.lastTokens = 0;
+    }
+    // Herramientas de un agente: las propias, task (si hay subagentes) y las de MCP, con sus filtros
+    toolsFor(agent, depth) {
+        let tools = [...CORE_TOOLS];
+        const subs = subagents(this.deps.agents).filter((sub) => sub.name !== agent.name);
+        if (depth === 0 && subs.length > 0) {
+            tools.push(taskTool(subs));
+        }
+        if (this.deps.skills.length > 0) {
+            tools.push(skillTool(this.deps.skills));
+        }
+        if (this.deps.mcp) {
+            tools.push(...this.deps.mcp.tools());
+        }
+        if (!this.deps.lsp || !this.deps.lsp.enabled()) {
+            tools = tools.filter((tool) => tool.name !== "diagnostics");
+        }
+        if (depth > 0) {
+            tools = tools.filter((tool) => tool.name !== "todowrite" && tool.name !== "todoread");
+        }
+        tools = tools.filter((tool) => toolEnabled(agent, tool.name));
+        if (agent.readOnly) {
+            tools = tools.filter((tool) => tool.readOnly);
+        }
+        return tools;
+    }
+    systemFor(agent, tools, depth) {
+        return {
+            role: "system",
+            content: systemPrompt(this.deps.root, {
+                agent,
+                toolNames: tools.map((tool) => tool.name),
+                instructions: this.deps.config.instructions || [],
+                subagent: depth > 0,
+            }),
+        };
+    }
+    // Texto que se añade al principio del siguiente mensaje tuyo (por ejemplo la salida de un !comando)
+    addNote(text) {
+        this.pendingNote += text;
+    }
+    toolContext(agent, signal, depth) {
+        const lsp = this.deps.lsp;
+        const ctx = {
+            root: this.deps.root,
+            bashTimeoutMs: this.deps.config.bashTimeoutMs,
+            signal,
+            ask: (request) => this.deps.ask(request, agent),
+            readTimes: this.readTimes,
+        };
+        if (lsp && lsp.enabled()) {
+            ctx.diagnostics = (file, all) => lsp.report(file, all);
+        }
+        if (depth === 0) {
+            ctx.todos = {
+                get: () => this.session.todos,
+                set: (list) => {
+                    this.session.todos = list;
+                    this.events.onTodos?.(list);
+                },
+            };
+            ctx.subagent = (type, prompt, description) => this.runSubagent(type, prompt, description, agent, signal);
+        }
+        return ctx;
+    }
+    requestTokens(messages, tools) {
+        return estimateTokens(messages) + estimateTokens(toolDefinitions(tools));
+    }
+    limit() {
+        return Math.min(this.deps.config.autoCompactTokens, Math.max(4000, this.deps.router.maxContext() * 0.8));
+    }
+    tooBig(tools) {
+        return this.requestTokens(this.fullMessages(tools), tools) > this.limit();
+    }
+    fullMessages(tools) {
+        return [this.systemFor(this.agent, tools, 0), ...this.session.messages];
+    }
+    // Vacía las salidas de herramientas antiguas (menos las últimas 6); devuelve true si ha recortado algo
+    prune(messages) {
+        const toolIndexes = [];
+        messages.forEach((message, index) => {
+            if (message.role === "tool") {
+                toolIndexes.push(index);
+            }
+        });
+        let changed = false;
+        for (const index of toolIndexes.slice(0, -6)) {
+            const message = messages[index];
+            if (typeof message.content === "string" && message.content.length > 500 && !message.content.includes("[… salida antigua recortada")) {
+                message.content = `${message.content.slice(0, 300)}\n[… salida antigua recortada para ahorrar contexto …]`;
+                changed = true;
+            }
+        }
+        return changed;
+    }
+    // Antes de mandar: primero recortamos salidas viejas y, si no basta, resumimos
+    async ensureRoom(tools, signal) {
+        if (!this.tooBig(tools)) {
+            return false;
+        }
+        if (this.prune(this.session.messages) && !this.tooBig(tools)) {
+            this.events.onInfo?.("He recortado salidas antiguas de herramientas para ahorrar contexto.");
+            return false;
+        }
+        // Recién resumida no hay nada más que ganar (el router avisará si no cabe en ningún modelo)
+        if (this.session.messages.length <= 3) {
+            return false;
+        }
+        await this.compact(signal);
+        return true;
+    }
+    // Resume la conversación para que quepa en modelos con poco contexto
+    async compact(signal) {
+        if (this.session.messages.length < 2) {
+            this.events.onInfo?.("No hay nada que resumir.");
+            return;
+        }
+        this.events.onInfo?.("Resumiendo la conversación…");
+        // Recortamos salidas de herramientas antiguas para que el propio resumen quepa
+        const trimmed = this.session.messages.map((m) => {
+            if (m.role === "tool" && typeof m.content === "string") {
+                return { ...m, content: truncate(m.content, 2000) };
+            }
+            return m;
+        });
+        const result = await this.deps.router.chat({
+            messages: [
+                { role: "system", content: "You are a precise assistant that writes handover summaries." },
+                ...trimmed,
+                { role: "user", content: COMPACT_PROMPT },
+            ],
+        }, signal, { onNotice: (t) => this.events.onNotice?.(t) });
+        const summary = result.message.content || "";
+        let todoText = "";
+        if (this.session.todos.length > 0) {
+            todoText = `\n\nLista de tareas actual:\n${this.session.todos.map((todo) => `- [${todo.status}] ${todo.content}`).join("\n")}`;
+        }
+        this.session.messages = [
+            { role: "user", content: `Resumen de la conversación anterior:\n\n${summary}${todoText}` },
+            { role: "assistant", content: "Entendido, sigo desde aquí." },
+        ];
+        this.session.epoch++;
+        saveSession(this.session);
+        this.events.onInfo?.(`Conversación resumida (~${estimateTokens(this.session.messages)} tokens).`);
+    }
+    // Si se canceló a mitad, puede haber llamadas a herramientas sin respuesta: los proveedores lo rechazan
+    repairHistory(messages = this.session.messages) {
+        for (let i = 0; i < messages.length; i++) {
+            const m = messages[i];
+            if (m.role !== "assistant" || !Array.isArray(m.tool_calls)) {
+                continue;
+            }
+            for (const call of m.tool_calls) {
+                const answered = messages.some((other) => other.role === "tool" && other.tool_call_id === call.id);
+                if (!answered) {
+                    // Insertamos la respuesta justo después de las que ya hay de este turno
+                    let insertAt = i + 1;
+                    while (insertAt < messages.length && messages[insertAt].role === "tool") {
+                        insertAt++;
+                    }
+                    messages.splice(insertAt, 0, { role: "tool", tool_call_id: call.id, content: "Cancelado por el usuario." });
+                }
+            }
+        }
+    }
+    buildUserMessage(input) {
+        const mentions = expandMentions(input.text, this.deps.root, this.readTimes);
+        for (const file of mentions.files) {
+            this.events.onInfo?.(`  + adjunto ${file}`);
+        }
+        const text = this.pendingNote + mentions.text;
+        this.pendingNote = "";
+        const images = [...(input.images || []), ...mentions.images];
+        if (images.length === 0) {
+            return { role: "user", content: text };
+        }
+        return {
+            role: "user",
+            content: [{ type: "text", text }, ...images.map((url) => ({ type: "image_url", image_url: { url } }))],
+        };
+    }
+    // Una llamada al modelo, con el texto y el razonamiento en directo
+    async step(messages, tools, agent, signal, depth) {
+        let printedText = false;
+        const result = await this.deps.router.chat({ messages, tools: toolDefinitions(tools), temperature: agent.temperature, prefer: agent.model }, signal, {
+            onText: (chunk) => {
+                printedText = true;
+                this.events.onText?.(chunk, depth);
+            },
+            onReasoning: (chunk) => this.events.onReasoning?.(chunk, depth),
+            onNotice: (notice) => this.events.onNotice?.(notice),
+            onAttempt: (slot) => this.events.onModel?.(slot, depth),
+        });
+        if (printedText) {
+            this.events.onTextEnd?.(depth);
+        }
+        let tokens = this.requestTokens(messages, tools);
+        if (result.usage) {
+            tokens = result.usage.prompt + result.usage.completion;
+            if (depth === 0) {
+                this.session.usage.prompt += result.usage.prompt;
+                this.session.usage.completion += result.usage.completion;
+            }
+        }
+        if (depth === 0) {
+            this.lastSlot = result.slot.key;
+            this.lastTokens = tokens;
+        }
+        this.events.onStep?.({ slot: result.slot.key, usage: result.usage, tokens });
+        return result;
+    }
+    // Ejecuta las herramientas que pidió el modelo; varios "task" seguidos van en paralelo
+    async runCalls(calls, tools, ctx, agent, depth, messages, signal) {
+        const images = [];
+        const runOne = async (call) => {
+            const name = call.function.name;
+            const args = call.function.arguments;
+            const event = { id: call.id, name, summary: describeCall(name, args), depth, agent: agent.name };
+            this.events.onToolStart?.(event);
+            const result = await runTool(tools, name, args, { ...ctx, onProgress: (text) => this.events.onToolProgress?.(event, text) }, agent.readOnly);
+            this.events.onToolEnd?.({ ...event, output: result.output, display: result.display, isError: Boolean(result.isError) });
+            if (result.images) {
+                images.push(...result.images);
+            }
+            return { role: "tool", tool_call_id: call.id, content: result.output };
+        };
+        const functionCalls = calls.filter((call) => call.type === "function");
+        let i = 0;
+        while (i < functionCalls.length) {
+            if (signal?.aborted) {
+                break;
+            }
+            if (functionCalls[i].function.name === "task") {
+                let j = i;
+                while (j < functionCalls.length && functionCalls[j].function.name === "task") {
+                    j++;
+                }
+                const results = await Promise.all(functionCalls.slice(i, j).map(runOne));
+                messages.push(...results);
+                i = j;
+            }
+            else {
+                messages.push(await runOne(functionCalls[i]));
+                i++;
+            }
+        }
+        if (images.length > 0) {
+            messages.push({
+                role: "user",
+                content: [{ type: "text", text: "Imágenes devueltas por las herramientas:" }, ...images.map((url) => ({ type: "image_url", image_url: { url } }))],
+            });
+        }
+    }
+    // Detecta cuando el modelo repite la misma llamada una y otra vez
+    repeated(history, calls) {
+        for (const call of calls) {
+            if (call.type !== "function") {
+                continue;
+            }
+            history.push(`${call.function.name}:${call.function.arguments}`);
+        }
+        if (history.length >= 3) {
+            const last = history.slice(-3);
+            if (last[0] === last[1] && last[1] === last[2]) {
+                history.length = 0;
+                return last[0].split(":")[0];
+            }
+        }
+        return null;
+    }
+    async run(input, signal) {
+        this.running = true;
+        let turn = null;
+        try {
+            this.repairHistory();
+            const tools = this.toolsFor(this.agent, 0);
+            await this.ensureRoom(tools, signal);
+            const before = this.deps.snapshots ? await this.deps.snapshots.track() : null;
+            beginTurn();
+            turn = { messageIndex: this.session.messages.length, before, after: null, epoch: this.session.epoch, userText: input.text };
+            this.session.turns.push(turn);
+            this.session.redo = [];
+            this.session.agent = this.agent.name;
+            this.session.messages.push(this.buildUserMessage(input));
+            saveSession(this.session);
+            await this.loop(tools, signal);
+        }
+        finally {
+            if (turn && this.deps.snapshots) {
+                turn.after = await this.deps.snapshots.track();
+            }
+            saveSession(this.session);
+            this.running = false;
+        }
+    }
+    async loop(tools, signal) {
+        const agent = this.agent;
+        const maxSteps = agent.maxSteps || this.deps.config.maxSteps;
+        const ctx = this.toolContext(agent, signal, 0);
+        const history = [];
+        for (let step = 0; step < maxSteps; step++) {
+            // Si la conversación crece demasiado a mitad de tarea, la resumimos y seguimos
+            if (await this.ensureRoom(tools, signal)) {
+                this.session.messages.push({ role: "user", content: "Continúa con la tarea pendiente." });
+            }
+            const result = await this.step(this.fullMessages(tools), tools, agent, signal, 0);
+            const message = result.message;
+            this.session.messages.push(message);
+            saveSession(this.session);
+            if (!message.tool_calls || message.tool_calls.length === 0) {
+                if (this.events.onAnswer) {
+                    this.events.onAnswer(result.slot.key);
+                }
+                else {
+                    this.events.onInfo?.(`  ${result.slot.key}`);
+                }
+                return;
+            }
+            await this.runCalls(message.tool_calls, tools, ctx, agent, 0, this.session.messages, signal);
+            saveSession(this.session);
+            if (signal?.aborted) {
+                return;
+            }
+            const looping = this.repeated(history, message.tool_calls);
+            if (looping) {
+                this.session.messages.push({
+                    role: "user",
+                    content: `Has hecho la misma llamada a ${looping} tres veces seguidas con los mismos argumentos. No la repitas: cambia de enfoque o explica qué te bloquea.`,
+                });
+            }
+            // Lo que hayas escrito mientras trabajaba se le entrega ahora
+            if (this.queue.length > 0) {
+                for (const queued of this.queue.splice(0)) {
+                    this.session.messages.push(this.buildUserMessage({ text: `[Mensaje nuevo del usuario mientras trabajabas] ${queued.text}`, images: queued.images }));
+                }
+                this.events.onInfo?.("(mensaje entregado al agente)");
+                saveSession(this.session);
+            }
+        }
+        this.events.onNotice?.(`Se alcanzó el máximo de ${maxSteps} pasos. Escribe "continúa" para seguir.`);
+    }
+    // Un subagente trabaja con su propio historial y devuelve solo su informe final
+    async runSubagent(type, prompt, description, parent, signal) {
+        let sub = subagents(this.deps.agents).find((agent) => agent.name === type);
+        if (!sub) {
+            sub = subagents(this.deps.agents).find((agent) => agent.name === "general");
+        }
+        if (!sub) {
+            return `Error: no existe el subagente ${type}.`;
+        }
+        // Un agente de solo lectura no puede saltarse la norma lanzando un subagente que edite
+        const agent = parent.readOnly ? { ...sub, readOnly: true } : sub;
+        const tools = this.toolsFor(agent, 1);
+        const ctx = this.toolContext(agent, signal, 1);
+        const messages = [{ role: "user", content: prompt }];
+        const maxSteps = agent.maxSteps || Math.min(this.deps.config.maxSteps, 30);
+        const history = [];
+        this.events.onInfo?.(`  ↳ ${agent.name}: ${description}`);
+        for (let step = 0; step < maxSteps; step++) {
+            const system = this.systemFor(agent, tools, 1);
+            if (this.requestTokens([system, ...messages], tools) > this.limit()) {
+                this.prune(messages);
+            }
+            const result = await this.step([system, ...messages], tools, agent, signal, 1);
+            messages.push(result.message);
+            if (!result.message.tool_calls || result.message.tool_calls.length === 0) {
+                return result.message.content || "(el subagente no devolvió ningún texto)";
+            }
+            await this.runCalls(result.message.tool_calls, tools, ctx, agent, 1, messages, signal);
+            if (signal?.aborted) {
+                return "Cancelado por el usuario.";
+            }
+            const looping = this.repeated(history, result.message.tool_calls);
+            if (looping) {
+                messages.push({ role: "user", content: `Has repetido la misma llamada a ${looping} tres veces. Cambia de enfoque o termina con lo que tengas.` });
+            }
+        }
+        this.repairHistory(messages);
+        const final = await this.deps.router.chat({
+            messages: [
+                this.systemFor(agent, tools, 1),
+                ...messages,
+                { role: "user", content: "Se acabaron los pasos. Escribe ya tu informe final con lo que hayas averiguado o hecho." },
+            ],
+        }, signal, { onNotice: (notice) => this.events.onNotice?.(notice) });
+        return final.message.content || "(el subagente no devolvió ningún informe)";
+    }
+    // Deshace el último mensaje: ficheros (con instantáneas, incluido lo que hizo bash) y conversación
+    async undo() {
+        const turn = this.session.turns.pop();
+        if (!turn) {
+            return null;
+        }
+        let files = [];
+        if (turn.before && this.deps.snapshots) {
+            files = await this.deps.snapshots.restore(turn.before);
+        }
+        else {
+            files = undoLastTurn(this.deps.root);
+        }
+        let removed = [];
+        let restoredMessages = false;
+        if (turn.epoch === this.session.epoch && turn.messageIndex <= this.session.messages.length) {
+            removed = this.session.messages.splice(turn.messageIndex);
+            restoredMessages = true;
+        }
+        else if (files.length > 0) {
+            this.pendingNote += `(Nota: el usuario ha deshecho tus últimos cambios en ${files.join(", ")}; esos ficheros vuelven a estar como antes. Léelos de nuevo si los necesitas.)\n\n`;
+        }
+        this.session.redo.push({ turn, messages: removed });
+        this.readTimes.clear();
+        saveSession(this.session);
+        return { files, text: turn.userText, restoredMessages };
+    }
+    async redo() {
+        const entry = this.session.redo.pop();
+        if (!entry) {
+            return null;
+        }
+        let files = [];
+        if (entry.turn.after && this.deps.snapshots) {
+            files = await this.deps.snapshots.restore(entry.turn.after);
+        }
+        if (entry.messages.length > 0 && entry.turn.epoch === this.session.epoch && this.session.messages.length === entry.turn.messageIndex) {
+            this.session.messages.push(...entry.messages);
+        }
+        this.session.turns.push(entry.turn);
+        this.readTimes.clear();
+        saveSession(this.session);
+        return { files };
+    }
+    // Diff de lo que ha cambiado en el último mensaje o en toda la sesión
+    async diff(all) {
+        if (!this.deps.snapshots) {
+            return "";
+        }
+        const turns = this.session.turns.filter((turn) => turn.before);
+        if (turns.length === 0) {
+            return "";
+        }
+        if (all) {
+            return this.deps.snapshots.diff(turns[0].before);
+        }
+        const last = turns[turns.length - 1];
+        return this.deps.snapshots.diff(last.before, last.after || undefined);
+    }
+}

package/dist/agents.js

@@ -0,0 +1,171 @@
+import path from "node:path";
+import { readMarkdownDir } from "./frontmatter.js";
+import { wildcardMatch } from "./match.js";
+import { GLOBAL_AGENTS_DIR } from "./paths.js";
+const PLAN_PROMPT = `You are in PLAN mode: you can only read and search (and browse the web). Do NOT try to modify anything.
+Investigate the code and reply with a concrete, step-by-step plan: which files to change, what to change in each one and how to verify it.`;
+const GENERAL_PROMPT = `You are a subagent launched by the main agent to do one task on your own.
+Work autonomously until the task is done; you cannot ask the user questions.
+Your final answer is the only thing the main agent will see: make it a complete, self-contained report (what you found or changed, with file paths and key details).`;
+const EXPLORE_PROMPT = `You are a fast, read-only exploration subagent.
+Use glob, grep, list_dir and read_file to answer the question about the codebase. Be efficient: search first, then read only what you need.
+Your final answer is the only thing the main agent will see: give precise findings with file paths and line numbers.`;
+const BUILTIN = [
+    {
+        name: "build",
+        description: "Agente principal: lee, edita ficheros y ejecuta comandos",
+        mode: "primary",
+        prompt: "",
+        tools: {},
+        readOnly: false,
+        color: "magenta",
+        builtIn: true,
+    },
+    {
+        name: "plan",
+        description: "Solo lectura: investiga y propone un plan sin tocar nada",
+        mode: "primary",
+        prompt: PLAN_PROMPT,
+        tools: {},
+        permission: { edit: "deny", bash: "deny" },
+        readOnly: true,
+        color: "blue",
+        builtIn: true,
+    },
+    {
+        name: "general",
+        description: "Subagente para investigar preguntas complejas o hacer tareas de varios pasos de forma autónoma (puede editar)",
+        mode: "subagent",
+        prompt: GENERAL_PROMPT,
+        tools: { task: false, todowrite: false, todoread: false },
+        readOnly: false,
+        color: "cyan",
+        builtIn: true,
+    },
+    {
+        name: "explore",
+        description: "Subagente rápido de solo lectura para encontrar ficheros, símbolos o entender cómo funciona algo del código",
+        mode: "subagent",
+        prompt: EXPLORE_PROMPT,
+        tools: { task: false, todowrite: false, todoread: false, webfetch: false, websearch: false },
+        readOnly: true,
+        color: "green",
+        builtIn: true,
+    },
+];
+// Nombres de herramientas de opencode → los de vipcode
+const ALIASES = {
+    read: "read_file",
+    write: "write_file",
+    edit: "edit_file",
+    patch: "edit_file",
+    multiedit: "edit_file",
+    list: "list_dir",
+    ls: "list_dir",
+};
+const COLORS = ["magenta", "blue", "cyan", "green", "yellow", "red", "white", "gray"];
+function normalizeTools(input) {
+    const result = {};
+    if (Array.isArray(input)) {
+        // Lista = solo estas herramientas
+        result["*"] = false;
+        for (const name of input) {
+            result[ALIASES[String(name)] || String(name)] = true;
+        }
+        return result;
+    }
+    if (input && typeof input === "object") {
+        for (const [name, enabled] of Object.entries(input)) {
+            result[ALIASES[name] || name] = Boolean(enabled);
+        }
+    }
+    return result;
+}
+function fromInput(name, input, base, source) {
+    let mode = input.mode || base?.mode || "all";
+    if (!["primary", "subagent", "all"].includes(mode)) {
+        mode = "all";
+    }
+    let color = input.color || base?.color || "yellow";
+    if (!COLORS.includes(color)) {
+        color = "yellow";
+    }
+    return {
+        name,
+        description: input.description || base?.description || `Agente ${name}`,
+        mode,
+        prompt: input.prompt ?? base?.prompt ?? "",
+        model: input.model || base?.model,
+        temperature: typeof input.temperature === "number" ? input.temperature : base?.temperature,
+        tools: { ...(base?.tools || {}), ...normalizeTools(input.tools) },
+        permission: input.permission || base?.permission,
+        maxSteps: typeof input.maxSteps === "number" ? input.maxSteps : base?.maxSteps,
+        readOnly: typeof input.readOnly === "boolean" ? input.readOnly : base?.readOnly ?? false,
+        color,
+        builtIn: base?.builtIn ?? false,
+        source: source || base?.source,
+    };
+}
+// Agentes integrados + ~/.vipcode/agents + .vipcode/agents y .opencode/agent(s) del proyecto + "agents" del config
+export function loadAgents(root, config) {
+    const agents = new Map();
+    for (const agent of BUILTIN) {
+        agents.set(agent.name, { ...agent, tools: { ...agent.tools } });
+    }
+    const dirs = [
+        GLOBAL_AGENTS_DIR,
+        path.join(root, ".opencode", "agent"),
+        path.join(root, ".opencode", "agents"),
+        path.join(root, ".vipcode", "agents"),
+    ];
+    const disabled = new Set();
+    const apply = (name, input, source) => {
+        if (input.disable) {
+            disabled.add(name);
+            return;
+        }
+        agents.set(name, fromInput(name, input, agents.get(name), source));
+    };
+    for (const entry of readMarkdownDir(dirs)) {
+        const data = entry.data;
+        apply(entry.name, {
+            description: data.description,
+            mode: data.mode,
+            prompt: entry.body,
+            model: data.model,
+            temperature: data.temperature,
+            tools: data.tools,
+            permission: data.permission,
+            maxSteps: data.maxSteps ?? data.steps,
+            color: data.color,
+            readOnly: data.readOnly,
+            disable: data.disable,
+        }, entry.file);
+    }
+    for (const [name, input] of Object.entries(config.agents || {})) {
+        apply(name, input);
+    }
+    for (const name of disabled) {
+        agents.delete(name);
+    }
+    if (!agents.has("build")) {
+        agents.set("build", { ...BUILTIN[0] });
+    }
+    return [...agents.values()];
+}
+export function primaryAgents(agents) {
+    return agents.filter((agent) => agent.mode === "primary" || agent.mode === "all");
+}
+export function subagents(agents) {
+    return agents.filter((agent) => agent.mode === "subagent" || agent.mode === "all");
+}
+// ¿Puede este agente usar la herramienta? Gana la última regla que encaje; por defecto sí
+export function toolEnabled(agent, toolName) {
+    let enabled = true;
+    for (const [pattern, value] of Object.entries(agent.tools)) {
+        if (pattern === toolName || wildcardMatch(pattern, toolName)) {
+            enabled = value;
+        }
+    }
+    return enabled;
+}