overseer-mcp 0.1.1

package/dist/index.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import { pathToFileURL } from "node:url";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { loadConfig } from "./config.js";
+import { runCodexConfig } from "./init/codexConfigCommand.js";
+import { runInit } from "./init/command.js";
+import { runInstructions } from "./init/instructionsCommand.js";
+import { consultExpertInputSchema, handleConsultExpert } from "./tools/consultExpert.js";
+import { getPlanInputSchema, handleGetPlan } from "./tools/getPlan.js";
+import { handleRequestReview, requestReviewInputSchema } from "./tools/requestReview.js";
+export function createServer(config) {
+    const server = new McpServer({ name: "overseer-mcp", version: "0.1.1" });
+    server.registerTool("get_plan", {
+        title: "Get implementation plan",
+        description: "Call before writing any code. Forward the user's request so the expert can produce a surgical plan from real git and disk context.",
+        inputSchema: getPlanInputSchema,
+    }, async (args) => handleGetPlan(args, config));
+    server.registerTool("consult_expert", {
+        title: "Consult expert",
+        description: "Call BEFORE improvising whenever you hit a non-trivial decision, an error you don't fully understand, or an ambiguity in the plan. Attach relevant file_paths and literal error_output.",
+        inputSchema: consultExpertInputSchema,
+    }, async (args) => handleConsultExpert(args, config));
+    server.registerTool("request_review", {
+        title: "Request final review",
+        description: "Call when implementation is done. The server sends real git diffs and optional validation output to the expert; finish only after APPROVE.",
+        inputSchema: requestReviewInputSchema,
+    }, async (args) => handleRequestReview(args, config));
+    return server;
+}
+export async function main() {
+    if (process.argv[2] === "init") {
+        await runInit(process.argv.slice(3), process, process.argv[1]);
+        return;
+    }
+    if (process.argv[2] === "instructions") {
+        await runInstructions(process.argv.slice(3), process);
+        return;
+    }
+    if (process.argv[2] === "codex-config") {
+        await runCodexConfig(process.argv.slice(3), process);
+        return;
+    }
+    let config;
+    try {
+        config = loadConfig();
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(message);
+        process.exit(1);
+    }
+    const server = createServer(config);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error(`overseer-mcp ready (${config.provider.id}) repoRoot=${config.repoRoot} cwd=${process.cwd()} VSCODE_CWD=${process.env.VSCODE_CWD ?? "unset"}`);
+}
+const entrypoint = process.argv[1] ? pathToFileURL(process.argv[1]).href : undefined;
+if (entrypoint === import.meta.url) {
+    main().catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+}

package/dist/init/codexConfig.js

@@ -0,0 +1,27 @@
+import { copyFile, readFile, writeFile } from "node:fs/promises";
+const serviceTierLine = /^(\s*)service_tier\s*=\s*"([^"]*)".*$/m;
+export function inspectCodexServiceTier(text) {
+    const match = serviceTierLine.exec(text);
+    if (!match)
+        return { state: "missing" };
+    const value = match[2];
+    if (value === "fast" || value === "flex")
+        return { state: "valid", value };
+    return { state: "invalid", value };
+}
+function applyServiceTierChoice(text, choice) {
+    if (choice === "remove") {
+        return text.replace(serviceTierLine, "").replace(/\n{3,}/g, "\n\n");
+    }
+    return text.replace(serviceTierLine, (_line, indent) => `${indent}service_tier = "${choice}"`);
+}
+export async function repairCodexConfigFile(configPath, choice) {
+    const text = await readFile(configPath, "utf8");
+    const status = inspectCodexServiceTier(text);
+    if (status.state !== "invalid")
+        return { changed: false, status };
+    const backupPath = `${configPath}.backup-${Date.now()}`;
+    await copyFile(configPath, backupPath);
+    await writeFile(configPath, applyServiceTierChoice(text, choice), "utf8");
+    return { changed: true, backupPath, status };
+}

package/dist/init/codexConfigCommand.js

@@ -0,0 +1,78 @@
+import { access, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import readline from "node:readline/promises";
+import { inspectCodexServiceTier, repairCodexConfigFile } from "./codexConfig.js";
+function write(stream, text) {
+    stream.write(text);
+}
+function getFlag(argv, key) {
+    const prefix = `--${key}=`;
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === `--${key}`)
+            return argv[index + 1];
+        if (arg.startsWith(prefix))
+            return arg.slice(prefix.length);
+    }
+    return undefined;
+}
+function parseChoice(value) {
+    if (value === undefined)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (!normalized || normalized === "1" || normalized === "flex")
+        return "flex";
+    if (normalized === "2" || normalized === "fast")
+        return "fast";
+    if (normalized === "3" || normalized === "remove")
+        return "remove";
+    return undefined;
+}
+async function chooseServiceTier(io) {
+    write(io.stdout, [
+        "Choose Codex service_tier:",
+        "  1. flex (recommended)",
+        "  2. fast",
+        "  3. remove service_tier line",
+        "",
+    ].join("\n"));
+    const rl = readline.createInterface({ input: io.stdin, output: io.stdout });
+    try {
+        const answer = (await rl.question("Choose [1]: ")).trim();
+        const choice = parseChoice(answer);
+        if (!choice)
+            throw new Error("Invalid service_tier choice");
+        return choice;
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function runCodexConfig(argv, io = process) {
+    const configPath = getFlag(argv, "path") ?? path.join(homedir(), ".codex", "config.toml");
+    const explicitChoice = parseChoice(getFlag(argv, "choice"));
+    try {
+        await access(configPath);
+    }
+    catch {
+        write(io.stdout, `No Codex config found at ${configPath}; skipping.\n`);
+        return;
+    }
+    const status = inspectCodexServiceTier(await readFile(configPath, "utf8"));
+    if (status.state !== "invalid") {
+        write(io.stdout, `Codex config service_tier is OK at ${configPath}.\n`);
+        return;
+    }
+    write(io.stdout, [
+        `Codex config has unsupported service_tier "${status.value}" at:`,
+        configPath,
+        'Codex CLI currently expects "fast" or "flex".',
+        "",
+    ].join("\n"));
+    const choice = explicitChoice ?? (await chooseServiceTier(io));
+    const result = await repairCodexConfigFile(configPath, choice);
+    if (result.changed) {
+        write(io.stdout, `Updated service_tier using "${choice}". Backup: ${result.backupPath}\n`);
+    }
+}

package/dist/init/command.js

@@ -0,0 +1,98 @@
+import { spawn } from "node:child_process";
+import readline from "node:readline/promises";
+import { buildCodexToml, buildGenericMcpJson, parseInitArgs, } from "./config.js";
+function write(stream, text) {
+    stream.write(text);
+}
+async function ask(rl, question, fallback) {
+    const suffix = fallback ? ` (${fallback})` : "";
+    const answer = (await rl.question(`${question}${suffix}: `)).trim();
+    return answer || fallback || "";
+}
+function parseExpertAnswer(answer) {
+    if (answer === "1" || answer === "openai-compatible")
+        return "openai-compatible";
+    if (answer === "2" || answer === "openai")
+        return "openai";
+    if (answer === "3" || answer === "anthropic")
+        return "anthropic";
+    if (answer === "4" || answer === "cli")
+        return "cli";
+    throw new Error("Invalid expert choice");
+}
+async function interactiveArgs(io, scriptPath) {
+    const rl = readline.createInterface({ input: io.stdin, output: io.stdout });
+    try {
+        write(io.stdout, [
+            "overseer-mcp init",
+            "",
+            "Expert options:",
+            "1. openai-compatible (custom baseUrl + API key: opencode-go, GLM, gateways)",
+            "2. openai (OpenAI API)",
+            "3. anthropic (Anthropic API)",
+            "4. cli (Codex/Claude/local CLI, optional login)",
+            "",
+        ].join("\n"));
+        const expert = parseExpertAnswer(await ask(rl, "Choose expert", "1"));
+        const args = ["--print", "--expert", expert, "--name", await ask(rl, "MCP server name", "overseer")];
+        args.push("--repo-root", await ask(rl, "Repo root", process.cwd()));
+        const testCommand = await ask(rl, "Validation command, empty to skip");
+        if (testCommand)
+            args.push("--test-command", testCommand);
+        if (expert === "cli") {
+            args.push("--cli-command", await ask(rl, "CLI command", "codex"));
+            const cliArgs = await ask(rl, "CLI args as JSON array", '["exec"]');
+            if (cliArgs)
+                args.push("--cli-args", cliArgs);
+            const login = await ask(rl, "Run CLI login now? yes/no", "no");
+            if (login.toLowerCase().startsWith("y"))
+                args.push("--run-login");
+        }
+        else {
+            args.push("--model", await ask(rl, "Expert model"));
+            const defaultKey = expert === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY";
+            args.push("--api-key-env", await ask(rl, "Environment variable that contains the API key", defaultKey));
+            const baseUrl = await ask(rl, "Base URL, empty for provider default");
+            if (baseUrl)
+                args.push("--base-url", baseUrl);
+        }
+        return parseInitArgs(args, scriptPath);
+    }
+    finally {
+        rl.close();
+    }
+}
+async function runLogin(parsed, io) {
+    if (!parsed.runLogin)
+        return;
+    if (!parsed.loginCommand || parsed.loginCommand.length === 0) {
+        write(io.stderr, "No login command is known for this CLI. Skipping login.\n");
+        return;
+    }
+    const [command, ...args] = parsed.loginCommand;
+    write(io.stderr, `Running: ${command} ${args.join(" ")}\n`);
+    await new Promise((resolve) => {
+        const child = spawn(command, args, {
+            stdio: ["inherit", process.stderr, "inherit"],
+            shell: false,
+        });
+        child.on("error", (err) => {
+            write(io.stderr, `Login failed to start: ${err.message}. Run "${command} login" manually in a terminal.\n`);
+            resolve();
+        });
+        child.on("close", (code) => {
+            if (code === 0)
+                resolve();
+            else {
+                write(io.stderr, `Login exited with code ${code}. You can run "${command} login" manually later.\n`);
+                resolve();
+            }
+        });
+    });
+}
+export async function runInit(argv, io = process, scriptPath) {
+    const parsed = argv.length > 0 ? parseInitArgs(argv, scriptPath) : await interactiveArgs(io, scriptPath);
+    await runLogin(parsed, io);
+    const text = parsed.target === "json" ? buildGenericMcpJson([parsed.profile]) : `${buildCodexToml([parsed.profile])}\n`;
+    write(io.stdout, text);
+}

package/dist/init/config.js

@@ -0,0 +1,204 @@
+import path from "node:path";
+function requireOption(value, name) {
+    if (!value) {
+        throw new Error(`Missing required init option: ${name}`);
+    }
+    return value;
+}
+function configPath(value) {
+    return value.replace(/\\/g, "/");
+}
+function quoteToml(value) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function arrayToml(values) {
+    return `[${values.map(quoteToml).join(", ")}]`;
+}
+function parseList(value) {
+    if (!value)
+        return [];
+    const trimmed = value.trim();
+    if (!trimmed)
+        return [];
+    if (trimmed.startsWith("[")) {
+        const parsed = JSON.parse(trimmed);
+        if (!Array.isArray(parsed) || !parsed.every((item) => typeof item === "string")) {
+            throw new Error("Expected a JSON string array");
+        }
+        return parsed;
+    }
+    return trimmed.split(/\s+/);
+}
+function readFlagMap(argv) {
+    const map = new Map();
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (!arg.startsWith("--"))
+            continue;
+        const inline = arg.indexOf("=");
+        const key = inline === -1 ? arg.slice(2) : arg.slice(2, inline);
+        const current = map.get(key) ?? [];
+        if (inline !== -1) {
+            current.push(arg.slice(inline + 1));
+        }
+        else if (argv[index + 1] && !argv[index + 1].startsWith("--")) {
+            current.push(argv[index + 1]);
+            index += 1;
+        }
+        else {
+            current.push("true");
+        }
+        map.set(key, current);
+    }
+    return map;
+}
+function getOne(flags, key) {
+    return flags.get(key)?.at(-1);
+}
+function getMany(flags, key) {
+    return flags.get(key) ?? [];
+}
+function parseTarget(value) {
+    if (!value)
+        return "codex";
+    if (value === "codex" || value === "json")
+        return value;
+    throw new Error("Invalid --target: expected codex or json");
+}
+function parseExpert(value) {
+    const expert = value ?? "openai-compatible";
+    if (expert === "openai" || expert === "openai-compatible" || expert === "anthropic" || expert === "cli") {
+        return expert;
+    }
+    throw new Error("Invalid --expert: expected openai, openai-compatible, anthropic, or cli");
+}
+function parsePromptVia(value) {
+    if (!value)
+        return undefined;
+    if (value === "stdin" || value === "arg")
+        return value;
+    throw new Error("Invalid --cli-prompt-via: expected stdin or arg");
+}
+export function buildProfileEnv(options) {
+    const env = {};
+    if (options.repoRoot)
+        env.OVERSEER_REPO_ROOT = configPath(options.repoRoot);
+    if (options.testCommand)
+        env.OVERSEER_TEST_COMMAND = options.testCommand;
+    if (options.expert === "cli") {
+        env.OVERSEER_PROVIDER = "cli";
+        env.OVERSEER_CLI_COMMAND = requireOption(options.cliCommand, "--cli-command");
+        if (options.cliArgs && options.cliArgs.length > 0) {
+            env.OVERSEER_CLI_ARGS = JSON.stringify(options.cliArgs);
+        }
+        env.OVERSEER_CLI_PROMPT_VIA = options.cliPromptVia ?? "stdin";
+        if (options.cliTimeoutMs)
+            env.OVERSEER_CLI_TIMEOUT_MS = options.cliTimeoutMs;
+        return env;
+    }
+    env.OVERSEER_PROVIDER = options.expert === "anthropic" ? "anthropic" : "openai";
+    if (options.apiKeyEnv) {
+        env.OVERSEER_API_KEY_ENV = options.apiKeyEnv;
+    }
+    else if (options.apiKey) {
+        env.OVERSEER_API_KEY = options.apiKey;
+    }
+    else {
+        env.OVERSEER_API_KEY_ENV = options.expert === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY";
+    }
+    if (options.baseUrl)
+        env.OVERSEER_BASE_URL = options.baseUrl;
+    env.OVERSEER_MODEL = requireOption(options.model, "--model");
+    return env;
+}
+export function buildCodexToml(profiles) {
+    return profiles
+        .map((profile) => {
+        const lines = [
+            `[mcp_servers.${profile.name}]`,
+            `command = ${quoteToml(profile.command)}`,
+            `args = ${arrayToml(profile.args)}`,
+        ];
+        if (profile.cwd)
+            lines.push(`cwd = ${quoteToml(configPath(profile.cwd))}`);
+        if (profile.envVars && profile.envVars.length > 0) {
+            lines.push(`env_vars = ${arrayToml(profile.envVars)}`);
+        }
+        lines.push("", `[mcp_servers.${profile.name}.env]`);
+        for (const [key, value] of Object.entries(profile.env)) {
+            lines.push(`${key} = ${quoteToml(value)}`);
+        }
+        return lines.join("\n");
+    })
+        .join("\n\n");
+}
+export function buildGenericMcpJson(profiles) {
+    const mcpServers = {};
+    for (const profile of profiles) {
+        mcpServers[profile.name] = {
+            command: profile.command,
+            args: profile.args,
+            ...(profile.cwd ? { cwd: configPath(profile.cwd) } : {}),
+            env: profile.env,
+        };
+    }
+    return `${JSON.stringify({ mcpServers }, null, 2)}\n`;
+}
+export function defaultServerCommand(scriptPath = process.argv[1] ?? "dist/index.js") {
+    return {
+        command: "node",
+        args: [configPath(path.resolve(scriptPath))],
+    };
+}
+export function defaultLoginCommand(cliCommand) {
+    if (cliCommand === "codex" || cliCommand === "claude") {
+        return [cliCommand, "login"];
+    }
+    return undefined;
+}
+export function parseInitArgs(argv, scriptPath) {
+    const flags = readFlagMap(argv);
+    const target = parseTarget(getOne(flags, "target"));
+    const expert = parseExpert(getOne(flags, "expert"));
+    const server = {
+        command: getOne(flags, "server-command") ?? defaultServerCommand(scriptPath).command,
+        args: getMany(flags, "server-arg"),
+    };
+    if (server.args.length === 0) {
+        server.args = defaultServerCommand(scriptPath).args;
+    }
+    const repoRoot = getOne(flags, "repo-root") ?? process.cwd();
+    const cliArgs = parseList(getOne(flags, "cli-args"));
+    const env = buildProfileEnv({
+        expert,
+        repoRoot,
+        testCommand: getOne(flags, "test-command"),
+        apiKeyEnv: getOne(flags, "api-key-env"),
+        apiKey: getOne(flags, "api-key"),
+        baseUrl: getOne(flags, "base-url"),
+        model: getOne(flags, "model"),
+        cliCommand: getOne(flags, "cli-command"),
+        cliArgs,
+        cliPromptVia: parsePromptVia(getOne(flags, "cli-prompt-via")),
+        cliTimeoutMs: getOne(flags, "cli-timeout-ms"),
+    });
+    const apiKeyEnv = env.OVERSEER_API_KEY_ENV;
+    const envVars = apiKeyEnv ? [apiKeyEnv] : undefined;
+    const cliCommand = getOne(flags, "cli-command");
+    const loginCommand = parseList(getOne(flags, "login-command"));
+    const defaultLogin = defaultLoginCommand(cliCommand);
+    return {
+        print: flags.has("print"),
+        target,
+        runLogin: flags.has("run-login"),
+        loginCommand: loginCommand.length > 0 ? loginCommand : defaultLogin,
+        profile: {
+            name: getOne(flags, "name") ?? "overseer",
+            command: server.command,
+            args: server.args,
+            cwd: repoRoot,
+            envVars,
+            env,
+        },
+    };
+}

package/dist/init/instructions.js

@@ -0,0 +1,137 @@
+export function buildAgentInstructions(options = {}) {
+    const mcpName = options.mcpServerName ?? "overseer";
+    return `# Overseer MCP Agent Instructions
+
+> **REGLA ABSOLUTA: Este archivo es un CONTRATO OBLIGATORIO, no una guia. Cada seccion marcada con BLOQUEO te impide avanzar si no la cumplis. Ignorar el flujo invalida todo el trabajo.**
+
+Estas instrucciones son para el agente operador: el modelo barato o ejecutor que edita el codigo. Aplican igual si el agente es Codex, Mimo, Qoder, Cline, Roo, Trae, Claude Code u otro agente compatible con MCP.
+
+---
+
+## BLOQUEO 0 — Verificacion de MCP (ANTES de cualquier otra accion)
+
+**NO podes escribir codigo, NO podes planificar, NO podes analizar archivos, NO podes responder al usuario con un plan propio hasta que este bloqueo se resuelva.**
+
+1. Busca en tu lista de herramientas MCP las tres herramientas: \`get_plan\`, \`consult_expert\`, \`request_review\`.
+2. Si las tres existen y estan disponibles → desbloqueado, continua.
+3. Si NO existen → **DETENETE INMEDIATAMENTE**. No hagas nada mas. Responde al usuario EXACTAMENTE esto:
+   > "El servidor MCP \`${mcpName}\` no esta disponible. Necesito que cargues \`overseer-mcp.json\` desde la raiz del repo en la configuracion MCP del IDE, y reinicies o recargues los servidores MCP. No puedo continuar sin estas herramientas."
+4. Si tu IDE permite instalar MCPs desde el agente, importa \`overseer-mcp.json\` de la raiz del repo (o \`generated/overseer-mcp.json\`). Despues de instalar, avisale al usuario que debe reiniciar el IDE.
+
+**PROHIBIDO:** inventar un reemplazo, simular llamadas MCP, o continuar sin el servidor.
+
+---
+
+## BLOQUEO 1 — Plan obligatorio (GATE de entrada)
+
+**NO podes escribir UNA SOLA LINEA de codigo sin haber llamado \`get_plan\` primero y haber recibido el plan del experto.**
+
+Flujo:
+1. Llama \`get_plan\` con la solicitud original del usuario. Pasale \`focus_paths\` si ya sabes que archivos importan.
+2. Espera la respuesta. El plan que devuelve ES tu contrato de trabajo.
+3. Lee el plan completo. Los \`STEPS\` del plan son tu lista de tareas obligatoria.
+4. **NO modifiques el plan. NO lo resumas. NO lo ignores.** Segui los pasos en orden.
+
+**PROHIBIDO:**
+- Escribir codigo antes de llamar \`get_plan\`.
+- Inventar tu propio plan y ejecutarlo sin consultar al experto.
+- Saltear pasos del plan recibido.
+- Modificar archivos que el plan marca como \`DO NOT TOUCH\`.
+
+---
+
+## BLOQUEO 2 — Implementacion con supervision
+
+Implementa el plan paso a paso. Durante la implementacion:
+
+**OBLIGATORIO llamar \`consult_expert\` ANTES de:**
+- Tomar una decision de diseno que el plan no cubre.
+- Interpretar un error que no entendes completamente.
+- Resolver una ambiguedad en el plan.
+- Elegir entre dos o mas enfoques posibles.
+
+**OBLIGATORIO pasar evidencia real:**
+- \`file_paths\`: rutas reales de los archivos involucrados.
+- \`error_output\`: salida literal del error o test, copiada de la terminal.
+- \`options_considered\`: las alternativas que ya evaluaste.
+
+**PROHIBIDO:**
+- Improvisar una decision sin consultar.
+- Usar tu propio resumen como evidencia en lugar de archivos y outputs reales.
+- Continuar implementando despues de un \`NEED_INFO\` sin aportar la evidencia pedida.
+
+---
+
+## BLOQUEO 3 — Revision final obligatoria (GATE de salida)
+
+**NO podes declarar la tarea completa sin que \`request_review\` devuelva \`APPROVE\`.**
+
+1. Cuando termines la implementacion, llama \`request_review\`.
+2. Si devuelve \`APPROVE\` → tarea terminada. Crea el reporte final.
+3. Si devuelve \`REQUEST_CHANGES\` → aplica SOLO los \`REQUIRED_FIXES\` listados y volve a llamar \`request_review\`.
+4. Repeti el ciclo hasta obtener \`APPROVE\`.
+
+**PROHIBIDO:**
+- Decir "la tarea esta lista" o "termine" sin haber recibido \`APPROVE\`.
+- Ignorar los \`REQUIRED_FIXES\` del review.
+- Hacer cambios adicionales despues de un \`REQUEST_CHANGES\` que no sean los fixes pedidos.
+
+---
+
+## Archivo MCP local
+
+El archivo \`overseer-mcp.json\` en la raiz del repo contiene la configuracion local con rutas absolutas de esta maquina.
+
+- Usalo para instalar o recargar el MCP en este IDE.
+- No lo subas a GitHub si contiene rutas absolutas o datos de tu maquina.
+
+## Login del experto CLI
+
+Si el experto es un CLI (Codex CLI, Claude CLI), el login lo guarda ese CLI en su config global, no el MCP.
+
+- Si hay error de autenticacion, avisale al usuario que ejecute el login del CLI correspondiente y reinicie el IDE.
+- No pidas reinstalar \`overseer-mcp\` por un problema de login.
+
+## Como llegan estas instrucciones
+
+- Si esta instruccion esta en \`AGENTS.md\`, \`CLAUDE.md\`, \`GEMINI.md\` o reglas persistentes del IDE, es **obligatoria y persistente**.
+- Si la recibis pegada en el chat, es instruccion de sesion.
+- Si hay conflicto con otro archivo, segui la instruccion mas especifica del usuario.
+
+---
+
+## Resumen del flujo (checklist obligatorio)
+
+\`\`\`
+[ ] BLOQUEO 0: Verifique que get_plan, consult_expert, request_review existen en mis herramientas MCP
+[ ] BLOQUEO 1: Llame get_plan → recibi plan → lo lei completo
+[ ] BLOQUEO 2: Implemente paso a paso, consulte expert en cada decision no trivial
+[ ] BLOQUEO 3: Llame request_review → obtuve APPROVE → cree reporte final
+\`\`\`
+
+**Si NO podes marcar un bloqueo como cumplido, NO avances al siguiente. Detenete y resolve el bloqueo.**
+
+## Reglas de implementacion
+
+- Cambios minimos y quirurgicos.
+- No inventes APIs, rutas, tablas, comandos ni dependencias.
+- No borres datos.
+- No cambies diseno o UX salvo que el usuario lo pida.
+- No refactorices codigo adyacente por gusto.
+- Preserva comportamiento existente.
+- Ejecuta la validacion indicada por el plan o por el proyecto.
+
+## Reporte final del agente operador
+
+Despues de recibir \`APPROVE\`, crea o actualiza \`OVERSEER_FINAL_REPORT.md\` en la raiz del repo con:
+
+- Resumen de lo que cambiaste.
+- Archivos tocados.
+- Decisiones tomadas y alternativas descartadas, si hubo.
+- Validacion ejecutada y resultado real.
+- Resultado de \`request_review\`.
+- Pendientes, riesgos o supuestos.
+
+Si \`request_review\` no devuelve \`APPROVE\`, el reporte debe decir que la tarea no esta terminada y listar los cambios requeridos.
+`;
+}

package/dist/init/instructionsCommand.js

@@ -0,0 +1,11 @@
+import { buildAgentInstructions } from "./instructions.js";
+function valueAfter(argv, name) {
+    const index = argv.indexOf(name);
+    if (index === -1)
+        return undefined;
+    return argv[index + 1];
+}
+export async function runInstructions(argv, io = process) {
+    const mcpServerName = valueAfter(argv, "--mcp-name") ?? "overseer";
+    io.stdout.write(buildAgentInstructions({ mcpServerName }));
+}