@danieltmn/tamnora 0.16.1 → 0.18.0

package/harness/packages/core/src/mcp/registry.js

@@ -54,7 +54,9 @@ export function registryServerToConfig(server) {
     if (runtime === 'npx' && !args.includes('-y')) args.unshift('-y');
     args.push(`${pkg.identifier}${pkg.version ? `@${pkg.version}` : ''}`);
     const env = {};
-    for (const variable of pkg.environmentVariables ?? []) env[variable.name] = '';
+    for (const variable of pkg.environmentVariables ?? []) {
+      env[variable.name] = variable.isRequired ? `env:${variable.name}` : '';
+    }
     const requiredEnv = (pkg.environmentVariables ?? []).filter((v) => v.isRequired).map((v) => v.name);
     return {
       id,
@@ -70,6 +72,32 @@ export function registryServerToConfig(server) {
   throw new Error('El servidor del registro no tiene remotes ni packages compatibles.');
 }
 
+/** Vista liviana de un server del registro, para mostrar candidatos sin instalar. */
+export function registryServerToCandidate(server) {
+  const id = slugifyId(server?.name) || 'mcp';
+  const remote = (server?.remotes ?? [])[0];
+  const pkg = (server?.packages ?? [])[0];
+  const runtime = pkg ? pkg.runtimeHint || (pkg.registryType === 'npm' ? 'npx' : 'uvx') : '';
+  const requiredEnv = (pkg?.environmentVariables ?? []).filter((v) => v.isRequired).map((v) => v.name);
+  const args = pkg
+    ? [
+        ...(pkg.runtimeArguments ?? []).filter((a) => a.type === 'positional' && a.value).map((a) => a.value),
+        `${pkg.identifier}${pkg.version ? `@${pkg.version}` : ''}`,
+      ]
+    : [];
+  return {
+    id,
+    name: server?.title || server?.name || id,
+    description: server?.description ?? '',
+    registry: server?.name ?? null,
+    transport: remote?.url ? 'http' : 'stdio',
+    url: remote?.url ?? null,
+    command: runtime || null,
+    args,
+    requiredEnv,
+  };
+}
+
 /**
  * Normaliza un snippet JSON a nuestra config. Acepta:
  *  - `{ command, args, env }` o `{ url }`

package/harness/packages/core/src/procs/detect.js

@@ -24,12 +24,53 @@ const SCRIPT_ORDER = ['dev', 'start', 'serve', 'preview'];
 const STATIC_SERVER = fileURLToPath(new URL('../../../../scripts/static-server.mjs', import.meta.url));
 const STATIC_PORT = 8080;
 
+/** Archivo por proyecto (relativo a su raiz) que define sus procesos de dev. */
+export const PROCS_FILE = '.tamnora/procs.json';
+
 function findStaticRoot(dir) {
   if (existsSync(path.join(dir, 'index.html'))) return '.';
   if (existsSync(path.join(dir, 'public', 'index.html'))) return 'public';
   return null;
 }
 
+/** True si `target` es `root` o vive dentro de el (sin salirse por `..`). */
+function isInside(root, target) {
+  const rel = path.relative(root, target);
+  return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+
+/**
+ * Procesos definidos a mano por el proyecto en `<root>/.tamnora/procs.json`.
+ * Formato: `{ "processes": [{ label?, dir?, command, args?, port? }] }` o un array
+ * directo. `dir` es relativo a la raiz y debe quedar dentro de ella. Cada chip
+ * sigue pasando por la whitelist (`processes.allow`) al arrancar.
+ */
+export function loadProjectProcs(root) {
+  const file = path.join(root, PROCS_FILE);
+  if (!existsSync(file)) return [];
+  const raw = readJson(file);
+  const list = Array.isArray(raw) ? raw : Array.isArray(raw?.processes) ? raw.processes : [];
+  const chips = [];
+  for (const entry of list) {
+    if (!entry || typeof entry !== 'object') continue;
+    const command = String(entry.command ?? '').trim();
+    if (!command) continue;
+    const rel = String(entry.dir ?? '').trim().replace(/^[/\\]+/, '');
+    const cwd = path.resolve(root, rel || '.');
+    if (!isInside(root, cwd) || !existsSync(cwd)) continue;
+    const port = entry.port ? Number(entry.port) : undefined;
+    chips.push({
+      label: String(entry.label ?? command).trim() || command,
+      command,
+      args: Array.isArray(entry.args) ? entry.args.map(String) : [],
+      cwd,
+      port: Number.isInteger(port) && port > 0 ? port : undefined,
+      source: 'project',
+    });
+  }
+  return chips;
+}
+
 /** Chip para servir `dir` como sitio estático con el servidor sin dependencias. */
 export function staticServerChip(dir, { port = STATIC_PORT, label } = {}) {
   return {
@@ -59,9 +100,9 @@ export function packageManager(dir) {
   return 'npm';
 }
 
-/** Devuelve chips `{ label, command, args, cwd }` para arrancar el proyecto. */
+/** Devuelve chips `{ label, command, args, cwd, source }` para arrancar el proyecto. */
 export function detectProcs(dir) {
-  const chips = [];
+  const auto = [];
   const pkg = readJson(path.join(dir, 'package.json'));
   if (pkg?.scripts && typeof pkg.scripts === 'object') {
     const pm = packageManager(dir);
@@ -70,29 +111,39 @@ export function detectProcs(dir) {
       const first = Object.keys(pkg.scripts)[0];
       if (first) names.push(first);
     }
-    for (const name of names) chips.push({ label: `${name} (${pm})`, command: pm, args: ['run', name], cwd: dir });
+    for (const name of names) auto.push({ label: `${name} (${pm})`, command: pm, args: ['run', name], cwd: dir });
   }
 
   if (existsSync(path.join(dir, 'artisan'))) {
-    chips.push({ label: 'artisan serve', command: 'php', args: ['artisan', 'serve'], cwd: dir });
+    auto.push({ label: 'artisan serve', command: 'php', args: ['artisan', 'serve'], cwd: dir });
   } else if (readJson(path.join(dir, 'composer.json'))?.scripts?.dev) {
-    chips.push({ label: 'composer dev', command: 'composer', args: ['run', 'dev'], cwd: dir });
+    auto.push({ label: 'composer dev', command: 'composer', args: ['run', 'dev'], cwd: dir });
   }
 
   for (const rel of ['public/index.php', 'backend/public/index.php', 'index.php']) {
     if (!existsSync(path.join(dir, rel))) continue;
     const docroot = path.dirname(rel) === '.' ? '.' : path.dirname(rel);
-    chips.push({ label: `php -S (${rel})`, command: 'php', args: ['-S', '127.0.0.1:8000', '-t', docroot], cwd: dir });
+    auto.push({ label: `php -S (${rel})`, command: 'php', args: ['-S', '127.0.0.1:8000', '-t', docroot], cwd: dir });
     break;
   }
 
-  if (!chips.length) {
+  if (!auto.length) {
     const staticRoot = findStaticRoot(dir);
     if (staticRoot) {
       const target = staticRoot === '.' ? dir : path.join(dir, staticRoot);
-      chips.push(staticServerChip(target));
+      auto.push(staticServerChip(target));
     }
   }
 
+  const chips = [];
+  const seen = new Set();
+  const add = (chip) => {
+    const key = `${chip.command}|${(chip.args ?? []).join(' ')}|${chip.cwd ?? ''}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    chips.push(chip);
+  };
+  for (const chip of loadProjectProcs(dir)) add(chip);
+  for (const chip of auto) add({ ...chip, source: 'auto' });
   return chips;
 }

package/harness/packages/core/src/procs/kill.js

@@ -71,16 +71,37 @@ async function pidsOnUnix(port) {
   return [];
 }
 
+function validPort(port) {
+  const value = Number(port);
+  if (!Number.isInteger(value) || value < 1 || value > 65535) {
+    throw new Error('Puerto inválido (usá 1-65535).');
+  }
+  return value;
+}
+
+/** PIDs escuchando en `port` (Windows `netstat` o Unix lsof/fuser/ss). */
+export async function pidsOnPort(port) {
+  const value = validPort(port);
+  return process.platform === 'win32' ? pidsOnWindows(value) : pidsOnUnix(value);
+}
+
+/**
+ * Estado de un puerto.
+ * @returns {Promise<{port:number,listening:boolean,pids:number[]}>}
+ */
+export async function portInfo(port) {
+  const value = validPort(port);
+  const pids = await pidsOnPort(value);
+  return { port: value, listening: pids.length > 0, pids };
+}
+
 /**
  * Kill every process listening on `port`.
  * @returns {Promise<{port:number,pids:number[],killed:number[],errors:string[]}>}
  */
 export async function killPort(port) {
-  const value = Number(port);
-  if (!Number.isInteger(value) || value < 1 || value > 65535) {
-    throw new Error('Puerto inválido (usá 1-65535).');
-  }
-  const pids = process.platform === 'win32' ? await pidsOnWindows(value) : await pidsOnUnix(value);
+  const value = validPort(port);
+  const pids = await pidsOnPort(value);
   const killed = [];
   const errors = [];
   for (const pid of pids) {

package/harness/packages/core/src/redact.js

@@ -27,6 +27,31 @@ export function isSecretName(name) {
   return SECRET_NAME.test(String(name ?? ''));
 }
 
+/**
+ * Nombre sensible con criterio mas estricto (para el scrub de entorno): solo
+ * credenciales reales, para no romper variables legitimas como `SSH_AUTH_SOCK`
+ * o `DBUS_SESSION_BUS_ADDRESS` que matchean el patron amplio de `isSecretName`.
+ */
+const SENSITIVE_ENV_NAME = /(API[_-]?KEY|ACCESS[_-]?KEY|SECRET|PASSWORD|PASSWD|TOKEN|CREDENTIAL|PRIVATE[_-]?KEY|OAUTH)/i;
+
+export function isSensitiveEnvName(name) {
+  return SENSITIVE_ENV_NAME.test(String(name ?? ''));
+}
+
+/**
+ * Copia el entorno sin las variables con nombre de credencial, para no filtrar
+ * secretos a un proceso hijo (`bash`). Conserva PATH/HOME/etc. Defensa en
+ * profundidad: el comando del modelo no puede leer `env` y ver las claves.
+ */
+export function scrubEnv(env = getEnv()) {
+  const out = {};
+  for (const [name, value] of Object.entries(env ?? {})) {
+    if (isSensitiveEnvName(name)) continue;
+    out[name] = value;
+  }
+  return out;
+}
+
 /**
  * Valores de entorno que hay que redactar: los de variables con nombre
  * sensible y al menos 8 caracteres (evita tapar valores triviales).

package/harness/packages/core/src/skills/catalog.js

@@ -0,0 +1,78 @@
+// Catalogo curado de skills sugeridas. Se instalan (copian su SKILL.md a la
+// casa) deshabilitadas; el usuario las habilita desde la consola.
+
+export const SKILLS_CATALOG = [
+  {
+    id: 'browser-qa',
+    name: 'QA de webs',
+    description: 'Verifica una web en el navegador headless antes de darla por buena.',
+    when: 'cuando toques HTML/CSS/JS de una web o necesites confirmar que renderiza',
+    body: `# QA de webs
+
+Cuando trabajes en una web, verificala en el navegador antes de dar el cambio por terminado.
+
+1. Levantá el dev server (pestaña procs o \`bash\`) y anotá el puerto.
+2. Sacá una captura con la tool \`screenshot\` sobre la URL local.
+3. Revisá el resultado y los errores de consola con \`console_errors\`.
+4. Si hay errores, corregí y repetí. No des por bueno un cambio sin una captura limpia.
+5. Para webs con JavaScript o Cloudflare que \`fetch_url\` no puede leer, usá \`screenshot\`/\`console_errors\`.`,
+  },
+  {
+    id: 'git-commits',
+    name: 'Commits del repo',
+    description: 'Convenciones de mensajes de commit y qué no commitear.',
+    when: 'cuando vayas a proponer o preparar un commit',
+    body: `# Commits
+
+- Mensajes en español, con prefijos tipo \`feat:\`, \`fix:\`, \`docs:\`, \`chore(release):\`.
+- Una unidad lógica por commit; no mezcles refactors con features.
+- Antes de commitear, revisá \`git status\` y \`git diff\`; commiteá solo lo que corresponde.
+- Nunca agregues \`.tamnora/\`, \`tamnora.json\`, \`.env*\`, \`.npmrc\` ni \`*.db\`.
+- No commitees, hagas push ni abras PRs si el usuario no lo pidió.`,
+  },
+  {
+    id: 'code-review',
+    name: 'Revisión de cambios',
+    description: 'Revisa el diff antes de commitear buscando riesgos y secretos.',
+    when: 'antes de commitear o cuando el usuario pida una revisión',
+    body: `# Revisión de cambios
+
+- Leé el diff completo con \`git_diff\`.
+- Buscá: secretos o claves hardcodeadas, rutas que se salen del workspace, cambios no pedidos, logs de datos sensibles.
+- Confirmá que cada cambio responde al pedido; si hay refactors de más, señalalo.
+- Verificá que el código nuevo tenga su test si el repo usa tests.
+- Devolvé un resumen breve con hallazgos y, si está todo bien, decilo explícitamente.`,
+  },
+  {
+    id: 'static-landing',
+    name: 'Landing estática',
+    description: 'Arma una página estática sin dependencias ni build.',
+    when: 'cuando pidan una landing o página simple',
+    body: `# Landing estática
+
+- \`index.html\` + \`styles.css\` (y \`script.js\` solo si hace falta). Sin frameworks ni build.
+- CSS moderno: variables, grid/flex, responsive con una columna en mobile.
+- Accesibilidad: \`lang\`, \`alt\` en imágenes, contraste y foco visible.
+- Sin errores de consola: verificalo con \`screenshot\`/\`console_errors\`.
+
+## Cierre
+Al terminar, levantá el sitio y confirmá con una captura que se ve bien en adaptable y en móvil.`,
+  },
+  {
+    id: 'changelog',
+    name: 'Changelog',
+    description: 'Mantiene CHANGELOG.md con entradas claras.',
+    when: 'cuando haya cambios que el usuario quiera registrar en el changelog',
+    body: `# Changelog
+
+- Mantené una sección \`## [No publicado]\` (o \`Unreleased\`) arriba con \`### Agregado\`, \`### Cambiado\`, \`### Corregido\`.
+- Entradas en imperativo y orientadas al usuario, no al archivo tocado.
+- Al publicar, mové lo de "No publicado" a la versión con fecha \`YYYY-MM-DD\`.
+- No dupliques entradas ni describas detalles internos irrelevantes.`,
+  },
+];
+
+/** Entrada del catalogo de skills por id. */
+export function skillCatalogEntry(id) {
+  return SKILLS_CATALOG.find((item) => item.id === id) ?? null;
+}

package/harness/packages/core/src/skills/remote.js

@@ -41,6 +41,57 @@ async function ghJson(url) {
   return res.json();
 }
 
+/**
+ * Busca skills en GitHub y devuelve refs (`owner/repo[/slug]`) instalables.
+ * Sin token usa la busqueda de repositorios (limitada); con token usa la
+ * busqueda de codigo por `filename:SKILL.md`, que es mucho mas precisa.
+ */
+export async function searchSkillsGithub(query, { token, limit = 10 } = {}) {
+  const q = String(query ?? '').trim();
+  if (!q) return [];
+  const headers = { 'User-Agent': 'tamnora-harness', Accept: 'application/vnd.github+json' };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const only = Math.max(1, Math.min(30, Number(limit) || 10));
+
+  if (token) {
+    const url = new URL(`${GITHUB_API}/search/code`);
+    url.searchParams.set('q', `${q} filename:SKILL.md`);
+    url.searchParams.set('per_page', String(only));
+    const res = await fetch(url.toString(), { headers });
+    if (!res.ok) throw new Error(`GitHub respondio HTTP ${res.status}`);
+    const data = await res.json();
+    return (data.items ?? [])
+      .map((item) => {
+        const [owner, repo] = String(item.repository?.full_name ?? '').split('/');
+        const parts = String(item.path ?? '').split('/');
+        const idx = parts.lastIndexOf('SKILL.md');
+        const slug = idx > 0 ? parts[idx - 1] : null;
+        return { ref: slug ? `${owner}/${repo}/${slug}` : `${owner}/${repo}`, owner, repo, slug, source: `${owner}/${repo}` };
+      })
+      .filter((r) => r.owner && r.repo);
+  }
+
+  const url = new URL(`${GITHUB_API}/search/repositories`);
+  url.searchParams.set('q', `${q} SKILL.md in:readme`);
+  url.searchParams.set('per_page', String(only));
+  const res = await fetch(url.toString(), { headers });
+  if (!res.ok) throw new Error(`GitHub respondio HTTP ${res.status}`);
+  const data = await res.json();
+  return (data.items ?? [])
+    .map((item) => {
+      const [owner, repo] = String(item.full_name ?? '').split('/');
+      return {
+        ref: `${owner}/${repo}`,
+        owner,
+        repo,
+        slug: null,
+        source: `${owner}/${repo}`,
+        description: item.description ?? '',
+      };
+    })
+    .filter((r) => r.owner && r.repo);
+}
+
 /**
  * Baja los archivos de una skill (`SKILL.md` y los del mismo directorio) desde
  * el repositorio de GitHub. Sin `slug`, toma el `SKILL.md` de la raiz.

package/harness/packages/core/src/tools/executors.js

@@ -6,6 +6,7 @@ import { globToRegExp, walkFiles } from './glob.js';
 import { diffLines } from './diff.js';
 import { captureScreenshot, readConsole } from '../browser/index.js';
 import { screenshotsDir } from '../config/home.js';
+import { scrubEnv } from '../redact.js';
 
 const MAX_READ_LINES = 2000;
 const MAX_LIST = 500;
@@ -314,7 +315,7 @@ export function bashTool(root, { command, timeout } = {}, { signal } = {}) {
     const seconds = Math.min(Math.max(Number(timeout) || 30, 1), 300);
     let child;
     try {
-      child = spawn(command, { cwd: root, shell: true, windowsHide: true });
+      child = spawn(command, { cwd: root, shell: true, windowsHide: true, env: scrubEnv(process.env) });
     } catch (err) {
       resolve(`Error ejecutando el comando: ${err.message}`);
       return;
@@ -359,7 +360,7 @@ function runGit(root, args) {
   return new Promise((resolve) => {
     let child;
     try {
-      child = spawn('git', args, { cwd: root, windowsHide: true });
+      child = spawn('git', args, { cwd: root, windowsHide: true, env: scrubEnv(process.env) });
     } catch (err) {
       resolve(`Error ejecutando git: ${err.message}`);
       return;
@@ -458,6 +459,93 @@ export function previewUrlTool(_root, { url } = {}) {
   return `Vista previa pedida: ${parsed.url}. La consola la abre en el panel de vista previa.`;
 }
 
+const QUESTION_TYPES = new Set(['text', 'textarea', 'select', 'confirm']);
+
+function normalizeQuestions(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const item of raw) {
+    if (!item || typeof item !== 'object') continue;
+    const id = String(item.id ?? '').trim();
+    const label = String(item.label ?? '').trim();
+    if (!id || !label) continue;
+    let type = QUESTION_TYPES.has(item.type) ? item.type : 'text';
+    const options = Array.isArray(item.options) ? item.options.map((o) => String(o)) : [];
+    if (type === 'select' && !options.length) type = 'text';
+    out.push({
+      id,
+      label,
+      type,
+      options,
+      placeholder: String(item.placeholder ?? ''),
+      required: item.required === true,
+    });
+    if (out.length >= 12) break;
+  }
+  return out;
+}
+
+function formatAnswer(value) {
+  if (value === undefined || value === null || value === '') return '(sin respuesta)';
+  if (Array.isArray(value)) return value.join(', ');
+  if (typeof value === 'boolean') return value ? 'sí' : 'no';
+  return String(value);
+}
+
+/**
+ * Pregunta al usuario con un formulario interactivo. La entrega es del cliente
+ * (como `speak`/`preview_url`): aca se normaliza el pedido y se espera la
+ * respuesta via `onQuestion`. Sin canal interactivo, se le pide al modelo que
+ * pregunte en el texto.
+ */
+export async function askUserTool(_root, args = {}, { onQuestion } = {}) {
+  const questions = normalizeQuestions(args.questions);
+  if (!questions.length) return 'Error: falta "questions" (una lista con id y label).';
+  if (typeof onQuestion !== 'function') {
+    return 'No hay formulario interactivo en este canal: hacé las preguntas en el texto de la respuesta.';
+  }
+  const result = await onQuestion({ title: String(args.title ?? '').trim(), questions });
+  if (!result || result.ok === false || result.cancelled) return 'El usuario no respondió el formulario.';
+  const answers = result.answers ?? {};
+  const lines = questions.map((q) => `- ${q.label}: ${formatAnswer(answers[q.id])}`);
+  return `Respuestas del usuario:\n${lines.join('\n')}`;
+}
+
+/**
+ * Ofrece opciones como botones tappables. La entrega es del cliente (como
+ * `speak`/`preview_url`): aca solo se valida; al tocar una, la consola manda la
+ * opcion como mensaje del usuario.
+ */
+export function offerChoicesTool(_root, { question, options } = {}) {
+  const prompt = String(question ?? '').trim();
+  const items = Array.isArray(options) ? options.map((o) => String(o).trim()).filter(Boolean).slice(0, 6) : [];
+  if (!prompt || !items.length) return 'Error: pasá "question" y "options" (2 a 6 opciones).';
+  return `Opciones mostradas al usuario: ${items.join(' | ')}. Al tocar una, la consola la manda como su mensaje.`;
+}
+
+const PLAN_STATUSES = new Set(['pending', 'active', 'done']);
+
+/**
+ * Muestra un plan/checklist interactivo. Solo lectura: el cliente lo dibuja; el
+ * modelo lo reemite para actualizar el estado de los pasos.
+ */
+export function showPlanTool(_root, { title, steps } = {}) {
+  const clean = Array.isArray(steps)
+    ? steps
+        .filter((step) => step && typeof step === 'object' && String(step.text ?? '').trim())
+        .slice(0, 20)
+        .map((step) => ({
+          text: String(step.text).trim(),
+          status: PLAN_STATUSES.has(step.status) ? step.status : 'pending',
+        }))
+    : [];
+  if (!clean.length) return 'Error: pasá "steps" (una lista con "text").';
+  const marks = { done: '[x]', active: '[~]', pending: '[ ]' };
+  const head = String(title ?? '').trim();
+  const lines = clean.map((step) => `- ${marks[step.status]} ${step.text}`);
+  return `Plan mostrado al usuario${head ? ` ("${head}")` : ''}:\n${lines.join('\n')}`;
+}
+
 /**
  * Captura de pantalla con el navegador headless del sistema. La guarda en la
  * casa (`screenshots/`) y devuelve un `meta.screenshot` para que la consola la
@@ -535,6 +623,9 @@ export const EXECUTORS = {
   git_commit: gitCommitTool,
   speak: speakTool,
   preview_url: previewUrlTool,
+  ask_user: askUserTool,
+  offer_choices: offerChoicesTool,
+  show_plan: showPlanTool,
   screenshot: screenshotTool,
   console_errors: consoleTool,
 };

package/harness/packages/core/src/tools/index.js

@@ -1,28 +1,49 @@
 import { createToolRegistry } from './registry.js';
+import { MCP_ROUTER_NAME, planMcpTools } from './mcp.js';
 
 export { createToolRegistry } from './registry.js';
 export { TOOL_DEFINITIONS, TOOL_NAMES } from './schema.js';
-export { DEFAULT_PERMISSIONS, evaluatePermission } from './permissions.js';
+export { DEFAULT_PERMISSIONS, evaluatePermission, bashGuard } from './permissions.js';
 export { resolveInRoot, toRel } from './paths.js';
 export { globToRegExp, walkFiles, DEFAULT_IGNORES } from './glob.js';
+export { MCP_ROUTER_NAME, MCP_AUTO_THRESHOLD, useLazyMcp, buildMcpIndex, mcpRouterDefinition, planMcpTools } from './mcp.js';
 export * as executors from './executors.js';
 
 /**
  * Combine local tools with an optional MCP registry into a single
  * `{ definitions, execute }` pair for the agent loop.
  *
+ * When the MCP registry advertises many tools (`mcpMode: 'auto'`/`'lazy'`),
+ * only the pinned tools keep their full schema and the rest are reached through
+ * the `mcp_call` router; the caller injects `buildMcpIndex(mcp.tools)` into the
+ * prompt so the model knows what exists.
+ *
  * @param {object} opts - same options as createToolRegistry, plus:
- * @param {{definitions:object[], handles:(n:string)=>boolean, call:Function}} [opts.mcp]
+ * @param {{definitions:object[], tools?:object[], handles:(n:string)=>boolean, call:Function}} [opts.mcp]
+ * @param {'auto'|'eager'|'lazy'} [opts.mcpMode]
+ * @param {string[]} [opts.mcpPinned] - tool/server names always exposed in full
+ * @param {number} [opts.mcpThreshold] - auto cut-over (default 12)
  */
-export function createTools({ mcp, ...registryOptions } = {}) {
+export function createTools({ mcp, mcpMode = 'auto', mcpPinned = [], mcpThreshold, ...registryOptions } = {}) {
   const registry = createToolRegistry(registryOptions);
-  const definitions = [...registry.definitions, ...(mcp?.definitions ?? [])];
+  const planned = planMcpTools(mcp, { mode: mcpMode, pinned: mcpPinned, threshold: mcpThreshold });
+  const definitions = [...registry.definitions, ...planned.definitions];
 
   async function execute(name, args, context) {
     if (registry.handles(name)) return registry.execute(name, args, context);
-    if (mcp?.handles?.(name)) return mcp.call(name, args);
+    // Las tools MCP y el router pasan por el mismo control de permisos que las
+    // locales (default `ask`): se evalua/consulta con el nombre real de la tool.
+    const routed = planned.routed && name === MCP_ROUTER_NAME;
+    const toolName = routed ? String(args?.tool ?? '').trim() : name;
+    if (mcp?.handles?.(toolName)) {
+      const toolArgs = routed ? args?.args ?? {} : args;
+      const decision = await registry.authorize(toolName, toolArgs);
+      if (decision === 'deny') return `Permiso denegado para "${toolName}".`;
+      return mcp.call(toolName, toolArgs);
+    }
+    if (routed) return `Herramienta MCP desconocida: "${toolName}". Mirá el índice de MCP.`;
     return `Error: herramienta desconocida "${name}".`;
   }
 
-  return { definitions, execute, registry };
+  return { definitions, execute, registry, mcp: { routed: planned.routed } };
 }

package/harness/packages/core/src/tools/labels.js

@@ -67,6 +67,8 @@ export function summarizeToolCall(name, args = {}) {
     case 'task':
     case 'spawn_agent':
       return shorten(a.description || a.prompt, 80);
+    case 'mcp_call':
+      return shorten(a.tool, 70);
     default:
       return '';
   }

package/harness/packages/core/src/tools/mcp.js

@@ -0,0 +1,91 @@
+// Enrutamiento de tools MCP (progressive disclosure). En vez de inyectar el
+// esquema de TODAS las tools MCP en cada turno (ruido de contexto y "fatiga de
+// atención"), cuando hay muchas se expone un indice compacto y una unica tool
+// router `mcp_call({ tool, args })`; las tools "fijadas" (hot) siguen cargadas
+// con su esquema completo.
+
+export const MCP_ROUTER_NAME = 'mcp_call';
+
+/** Corte de `auto`: por debajo de esto se cargan completas, por encima se difiere. */
+export const MCP_AUTO_THRESHOLD = 12;
+
+const INDEX_DESC_CHARS = 140;
+
+/** Decide si conviene diferir las tools MCP segun el modo y el total. */
+export function useLazyMcp(mode = 'auto', total = 0, threshold = MCP_AUTO_THRESHOLD) {
+  if (mode === 'eager') return false;
+  if (mode === 'lazy') return total > 0;
+  return total > threshold;
+}
+
+/**
+ * Indice compacto agrupado por servidor (nombre + descripcion recortada), sin
+ * los esquemas. El modelo lo lee y llama `mcp_call` con el nombre exacto.
+ */
+export function buildMcpIndex(tools = []) {
+  if (!Array.isArray(tools) || !tools.length) return '';
+  const groups = new Map();
+  for (const tool of tools) {
+    const key = tool.server ?? 'mcp';
+    if (!groups.has(key)) groups.set(key, { name: tool.serverName ?? key, tools: [] });
+    groups.get(key).tools.push(tool);
+  }
+  const blocks = [
+    [
+      'Tenés herramientas MCP disponibles, pero son demasiadas para cargarlas todas en contexto.',
+      'Según la tarea, usá `mcp_call({ tool, args })` con el nombre exacto de la herramienta de este índice:',
+    ].join(' '),
+  ];
+  for (const group of groups.values()) {
+    const lines = [`\n## ${group.name}`];
+    for (const tool of group.tools) {
+      const desc = String(tool.description ?? '').replace(/\s+/g, ' ').trim();
+      const hint = desc.length > INDEX_DESC_CHARS ? `${desc.slice(0, INDEX_DESC_CHARS)}…` : desc;
+      lines.push(`- ${tool.name}${hint ? ` — ${hint}` : ''}`);
+    }
+    blocks.push(lines.join('\n'));
+  }
+  return blocks.join('\n');
+}
+
+/** Definicion (OpenAI-schema) del router que ejecuta cualquier tool MCP. */
+export function mcpRouterDefinition() {
+  return {
+    type: 'function',
+    function: {
+      name: MCP_ROUTER_NAME,
+      description:
+        'Ejecuta una herramienta MCP por su nombre completo. Usala para las herramientas del índice de MCP que no estén cargadas directamente (hay demasiadas para exponerlas todas).',
+      parameters: {
+        type: 'object',
+        properties: {
+          tool: { type: 'string', description: 'Nombre completo, ej. "mcp__postgres__query".' },
+          args: { type: 'object', description: 'Argumentos de la herramienta (según su esquema).' },
+        },
+        required: ['tool'],
+      },
+    },
+  };
+}
+
+function isPinned(name, pinned) {
+  for (const entry of pinned) {
+    const text = String(entry ?? '').trim();
+    if (!text) continue;
+    if (name === text || name.startsWith(`mcp__${text}__`)) return true;
+  }
+  return false;
+}
+
+/**
+ * Elige que definiciones de MCP exponer este turno.
+ * @returns {{definitions:object[], routed:boolean}}
+ */
+export function planMcpTools(mcp, { mode = 'auto', pinned = [], threshold = MCP_AUTO_THRESHOLD } = {}) {
+  const all = Array.isArray(mcp?.definitions) ? mcp.definitions : [];
+  if (!all.length) return { definitions: [], routed: false };
+  if (!useLazyMcp(mode, all.length, threshold)) return { definitions: all, routed: false };
+  const hot = Array.isArray(pinned) ? pinned : [];
+  const eager = all.filter((d) => isPinned(d.function?.name, hot));
+  return { definitions: [...eager, mcpRouterDefinition()], routed: true };
+}