@danieltmn/tamnora 0.16.1 → 0.18.0

package/CHANGELOG.md

@@ -5,6 +5,51 @@ Todos los cambios relevantes de este proyecto se documentan en este archivo.
 El formato sigue [Keep a Changelog](https://keepachangelog.com/es-ES/1.1.0/)
 y el proyecto usa [Versionado Semantico](https://semver.org/lang/es/).
 
+## [0.18.0] - 2026-10-12
+
+### Agregado
+
+- **UI interactiva**: el agente pide un **formulario** (`ask_user`), ofrece
+  **botones** (`offer_choices`) o muestra un **checklist** (`show_plan`); la
+  consola los renderiza (el formulario pausa el turno, los botones se mandan como
+  mensaje, el checklist tiene estado) y los reconstruye al recargar la sesión.
+- **MCP con carga diferida**: cuando hay muchas tools, se expone un índice y un
+  router `mcp_call` en vez de inyectar todos los esquemas (`mcpMode` `auto` /
+  `eager` / `lazy`; `mcpPinned` fija tools o servidores). Ajustes → MCP muestra
+  modo, fijas y conteo en contexto.
+- **Catálogo y búsqueda de MCP y skills**: catálogo curado en "sugeridos" (se
+  agregan deshabilitados) y búsqueda en el registro oficial de MCP y en GitHub. El
+  agente suma `search_mcp` / `install_mcp` y `search_skills` / `install_skill`.
+- **Preview remoto**: la pestaña preview publica el dev server por Tailscale
+  (`tailscale serve --https=8443`) para verlo desde otro dispositivo.
+
+### Cambiado
+
+- **Voz (Edge)**: la síntesis usa el host nuevo
+  (`api.msedgeservices.com/.../websocket/v1`) con el token como
+  `Ocp-Apim-Subscription-Key`; el host viejo respondía 403.
+- **Asesor**: la tarjeta cambia de color y etiqueta según el tipo
+  (código / explicación / consejo / resumen).
+
+### Seguridad
+
+- **Tools MCP por permisos**: ahora pasan por el mismo control que las locales
+  (default `ask`); antes se ejecutaban sin consultar. Se habilita por tool con
+  `permissions: { "mcp__...": "allow" }`.
+- **Endurecimiento de `bash`**: piso de seguridad que **deniega** los comandos
+  catastróficos aunque la política sea `allow` o `--yes` (`rm -rf /`/`~`, fork
+  bomb, `mkfs`, `dd of=/dev/`, formatear/borrar una unidad) y marca como `ask` los
+  irreversibles (`git push --force`, `git reset --hard`, `git clean -f`).
+- **Scrub de entorno**: `bash` y los `git` locales ya no heredan las variables con
+  nombre de credencial (`*_API_KEY`, `*_TOKEN`, `*PASSWORD`, ...).
+
+## [0.17.0] - 2026-10-11
+
+### Cambios
+
+- docs: procesos de desarrollo e interrumpir el turno
+- feat: procesos por proyecto, /port y /portkill, e interrumpir el turno
+
 ## [0.16.1] - 2026-10-10
 
 ### Cambios

package/README.md

@@ -22,8 +22,11 @@ con TUI, consola web, tools locales, MCP y evaluacion de modelos.
   que se inyectan solo cuando el agente toca el archivo.
 - **Automatizacion**: tareas programadas (`every`, `daily`, cron) que corren solas
   y **deshacer** un turno (restaura los archivos a como estaban).
-- **Contexto y costo**: skills on-demand, auto-compactacion, `max_tokens` por ronda
-  y prompt caching.
+- **Contexto y costo**: skills on-demand, MCP con **carga diferida** (índice +
+  router `mcp_call`), auto-compactacion, `max_tokens` por ronda y prompt caching.
+- **UI interactiva**: el agente pide un **formulario** (`ask_user`), ofrece
+  **botones** (`offer_choices`) o muestra un **checklist** (`show_plan`); la
+  consola los renderiza.
 - **Plataforma**: hooks y plugins locales (`.tamnora/hooks`, `.tamnora/plugins`).
 
 ## Instalacion
@@ -117,6 +120,10 @@ menu "mas" (los tres puntitos). En el chat:
   volver, la consola **reconecta** y reconstruye el progreso. Para cortarlo se usa
   el boton de detener (o `POST /api/sessions/:id/stop`), que ademas corta el stream
   del modelo y mata las tools de larga duracion (p. ej. `bash`) en curso.
+- **Encolar o interrumpir**: si el agente esta trabajando, lo que envias queda en
+  una **cola** visible y se manda al terminar. Para cortarlo y mandar el mensaje
+  **ya**, usa el boton **interrumpir** (⚡) o **Ctrl/Cmd+Enter**: cancela el turno en
+  curso y arranca el nuevo apenas se desenrolla.
 - **Solo lo pedido (estricto)**: el toggle de la pestaña Agente (o `PUT
   /api/settings` con `strictScope`) hace que el agente se limite a lo solicitado,
   sin mejoras ni cambios extra; se combina con Plan o Build.
@@ -128,7 +135,8 @@ menu "mas" (los tres puntitos). En el chat:
 - **Actualizar**: cuando npm tiene una version nueva aparece un banner para
   actualizar con un click; el server se reinicia solo.
 - **Comandos**: el input muestra un menu al escribir `/` (`/new`, `/init`, `/goal`,
-  `/resumen`, `/audioresumen`, `/compact`, `/clear`, `/cwd`, `/kill`, `/help`).
+  `/resumen`, `/audioresumen`, `/compact`, `/clear`, `/cwd`, `/port`, `/portkill`,
+  `/help`).
 - **Capturas**: el tool `screenshot` muestra la imagen inline en su tarjeta.
 
 ### Memoria, reglas y automatizacion
@@ -149,6 +157,20 @@ menu "mas" (los tres puntitos). En el chat:
   archivo; con **deshacer cambios** (menú `⋮` de cada respuesta) se restauran los
   archivos y se borra el turno del historial.
 
+### UI interactiva
+
+El agente no numera preguntas en el texto: cuando necesita decidir algo, usa un
+componente que la consola dibuja.
+
+- **Formulario** (`ask_user`): pausa el turno y devuelve las respuestas (texto,
+  textarea, select o confirmar). En Telegram/CLI cae a una pregunta en prosa.
+- **Botones** (`offer_choices`): opciones tappables; al tocar una se manda como tu
+  mensaje (bifurcaciones A/B/C). No pausa el turno.
+- **Checklist** (`show_plan`): pasos con estado (`pending`/`active`/`done`); es de
+  solo lectura y el agente lo reemite para actualizarlo.
+
+Los tres se renderizan en vivo y se reconstruyen al recargar la consola.
+
 ### Contexto y costo
 
 - **Skills on-demand**: en vez de inyectar todas las skills, el prompt lleva un
@@ -174,6 +196,21 @@ Laravel, PHP) y abrir un tunel al puerto para verlo desde el celular. Para sitio
 **estaticos** (un `index.html` sin script de dev) ofrece un chip "sitio estatico"
 que los sirve con un servidor sin dependencias (`harness/scripts/static-server.mjs`).
 
+En un **monorepo** donde cada parte arranca distinto, el proyecto declara sus
+procesos en `.tamnora/procs.json` (relativo al proyecto seleccionado); salen
+primero, se suman a los detectados y **solo** se pueden lanzar los que pasan por
+la allowlist `processes.allow`:
+
+```jsonc
+{ "processes": [
+  { "label": "backend",  "dir": "backend",  "command": "node", "args": ["index.js"], "port": 3000 },
+  { "label": "frontend", "dir": "frontend", "command": "npm",  "args": ["run", "dev"], "port": 5173 }
+] }
+```
+
+Los puertos se consultan y se liberan desde el chat: `/port <puerto>` dice si esta
+activo (y que PID lo usa) y `/portkill <puerto>` mata el proceso que lo escucha.
+
 El visor de archivos tiene **vista previa**: `.html`/`.svg` se sirven con sus CSS,
 JS e imagenes relativas, y `.md` se renderiza como markdown. Ambas vistas suman
 selector de tamano (movil/tablet/laptop/pc/adaptable) y boton para maximizar.
@@ -249,14 +286,31 @@ Los MCP stdio **no heredan `process.env`**: reciben un baseline minimo mas el
 (ver [`SECURITY.md`](SECURITY.md)). Para un servidor de confianza que necesite el
 entorno completo, `"inheritEnv": true`.
 
+Cuando hay **muchas** tools MCP, el harness no inyecta todos los esquemas en cada
+turno: expone un **indice** y una tool router `mcp_call({ tool, args })`, y deja
+solo las "calientes" con esquema completo (`mcpMode`: `auto` | `eager` | `lazy`;
+`mcpPinned` fija tools o servidores enteros). Ademas, las tools MCP pasan por los
+**mismos permisos** que las locales (default `ask`): se habilita por tool con
+`permissions: { "mcp__postgres__query": "allow" }`. Se ajustan en Ajustes → MCP.
+
+Desde Ajustes → MCP tambien hay un **catalogo de sugeridos** y busqueda en el
+registro oficial; se agregan deshabilitados y los prendes cuando quieras.
+
 ## Tools
 
 Tools locales confinadas al workspace (`read`, `list`, `glob`, `grep`, `write`,
 `edit`, `bash`, `fetch_url`), de navegador (`screenshot`, `console_errors`,
-`preview_url`), de voz (`speak`), de Git (`git_status`, `git_diff`, `git_log`,
+`preview_url`), de voz (`speak`), de interfaz interactiva (`ask_user`,
+`offer_choices`, `show_plan`), de Git (`git_status`, `git_diff`, `git_log`,
 `git_commit`) y de conocimiento (`memory`, `skill`), con permisos
 `allow`/`ask`/`deny` por tool o por patron.
 
+`bash` esta **endurecido**: un piso de seguridad **deniega** los comandos
+catastroficos (`rm -rf /`/`~`, fork bomb, `mkfs`, `dd of=/dev/`, formatear/borrar
+una unidad) aunque la politica sea `allow`, marca como `ask` los irreversibles
+(`git push --force`, `git reset --hard`) y el shell **no hereda** las variables con
+nombre de credencial (`scrubEnv`), asi que no filtra tus API keys.
+
 `fetch_url` lee URLs (HTML a texto) y avisa cuando un sitio exige JavaScript o
 esta detras de Cloudflare; para esos casos las tools `screenshot` / `console_errors`
 usan el **Chrome/Edge/Chromium del sistema** como navegador headless (sin

package/SECURITY.md

@@ -35,6 +35,14 @@ asi que se lo debe tratar como codigo con acceso a tu usuario.
   servidores de confianza. Un tool tipo `get-env` no puede leer tus secretos del
   shell, y los resultados MCP se **redactan** (`redactSecrets`) por si devuelven un
   token. No pases credenciales en los argumentos de las tools: van por `env`.
+- **Tools locales y `bash`**: `bash` corre en tu maquina como tu usuario, asi que
+  hay un piso de seguridad que **no se puede saltear** ni con `bash: "allow"` ni
+  con `--yes`: los comandos catastroficos (`rm -rf /`/`~`, fork bomb, `mkfs`,
+  `dd of=/dev/`, formatear/borrar una unidad) quedan **denegados**, y los
+  irreversibles (`rm -rf *`/`.`, `git push --force`, `git reset --hard`,
+  `git clean -f`) al menos `ask`. Ademas el shell y los `git` locales **no heredan**
+  las variables con nombre de credencial (`scrubEnv` quita `*_API_KEY`, `*_TOKEN`,
+  `*PASSWORD`, ...), asi que `env`/`printenv` no filtran tus claves del proceso.
 
 ## Buenas practicas
 

package/harness/packages/cli/src/commands/mcp.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { loadConfig, buildMcpRegistry, mcpTransport } from '../lib/core.js';
+import { loadConfig, buildMcpRegistry, mcpTransport, Store, databasePath } from '../lib/core.js';
 import { parse } from '../lib/util.js';
 import { color } from '../ui/color.js';
 
@@ -9,6 +9,26 @@ const OPTIONS = {
   help: { type: 'boolean', short: 'h' },
 };
 
+/** Servidores de `tamnora.json` + los guardados desde la consola (gana la base). */
+function mergedServers(config, store) {
+  const fromConfig = Array.isArray(config.mcp) ? config.mcp : [];
+  const fromStore = store.listMcpServers().map((row) => ({
+    id: row.id,
+    name: row.name ?? row.id,
+    type: row.transport ?? 'stdio',
+    command: row.command ?? undefined,
+    args: Array.isArray(row.config?.args) ? row.config.args : [],
+    url: row.url ?? undefined,
+    env: row.config?.env ?? undefined,
+    inheritEnv: row.config?.inheritEnv === true,
+    enabled: row.enabled !== false,
+  }));
+  const byId = new Map();
+  for (const server of fromConfig) if (server?.id) byId.set(server.id, server);
+  for (const server of fromStore) byId.set(server.id, server);
+  return [...byId.values()].filter((server) => server.enabled !== false);
+}
+
 export async function mcpCommand(argv) {
   const { values } = parse(argv, OPTIONS);
   if (values.help) {
@@ -18,11 +38,17 @@ export async function mcpCommand(argv) {
 
   const cwd = values.dir ? path.resolve(values.dir) : process.cwd();
   const config = await loadConfig(cwd);
-  const servers = Array.isArray(config.mcp) ? config.mcp : [];
+  const store = new Store(databasePath(cwd));
+  let servers;
+  try {
+    servers = mergedServers(config, store);
+  } finally {
+    store.close?.();
+  }
 
   if (!servers.length) {
     if (values.json) process.stdout.write(`${JSON.stringify({ servers: [] }, null, 2)}\n`);
-    else process.stdout.write(color.dim('No hay servidores MCP configurados en tamnora.json.\n'));
+    else process.stdout.write(color.dim('No hay servidores MCP habilitados (tamnora.json + consola).\n'));
     return 0;
   }
 
@@ -93,7 +119,8 @@ function safeTransport(server) {
 function printHelp() {
   console.log(`Uso: tamnora mcp [opciones]
 
-Conecta a los servidores MCP de tamnora.json y lista sus herramientas.
+Conecta a los servidores MCP habilitados (de tamnora.json y de la consola) y
+lista sus herramientas.
 
 Opciones:
   --dir <path>   Directorio del proyecto (tamnora.json)

package/harness/packages/cli/src/commands/repl.js

@@ -9,7 +9,7 @@ import {
   scopeDirective,
 } from '../lib/core.js';
 import { parse, databasePath, num } from '../lib/util.js';
-import { buildSystemPrompt, runTurn, createPrinter, resolveCliProvider } from '../lib/runtime.js';
+import { buildSystemPrompt, runTurn, createPrinter, resolveCliProvider, mcpSettings, mcpIndexBlock } from '../lib/runtime.js';
 import { color } from '../ui/color.js';
 
 const OPTIONS = {
@@ -31,11 +31,12 @@ export async function replCommand(argv) {
 
   const instructions = await loadInstructions(cwd, config.instructions);
   let systemExtra = '';
+  let mcpBlock = '';
   const maxRounds = num(values['max-steps'], config.maxRounds);
   const store = new Store(databasePath(cwd));
   let strict = values.strict ? true : values['no-strict'] ? false : store.getSetting('strictScope') === true;
   const buildPrompt = () =>
-    buildSystemPrompt(instructions, [systemExtra, scopeDirective(strict)].filter(Boolean).join('\n\n'));
+    buildSystemPrompt(instructions, [systemExtra, mcpBlock, scopeDirective(strict)].filter(Boolean).join('\n\n'));
   const resolved = resolveCliProvider(store, config, { provider: values.provider, model: values.model });
   let providerId = resolved.providerId;
   let model = resolved.model;
@@ -76,6 +77,8 @@ export async function replCommand(argv) {
       process.stdout.write(color.yellow(`MCP: ${err.message}\n`));
     }
   }
+  const { mode: mcpMode, pinned: mcpPinned } = mcpSettings(store, config);
+  mcpBlock = mcpIndexBlock(mcp, { mode: mcpMode });
   const enabled = values['no-tools']
     ? []
     : values.tools
@@ -90,6 +93,8 @@ export async function replCommand(argv) {
     yes: Boolean(values.yes),
     onAsk,
     mcp,
+    mcpMode,
+    mcpPinned,
   });
 
   process.stdout.write(color.dim(`Tamnora REPL · ${providerId}/${model}\n`));

package/harness/packages/cli/src/commands/run.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { loadConfig, loadInstructions, Store, createTools, buildMcpRegistry, scopeDirective } from '../lib/core.js';
 import { parse, databasePath, num } from '../lib/util.js';
-import { buildSystemPrompt, runTurn, createPrinter, resolveCliProvider } from '../lib/runtime.js';
+import { buildSystemPrompt, runTurn, createPrinter, resolveCliProvider, mcpSettings, mcpIndexBlock } from '../lib/runtime.js';
 import { color } from '../ui/color.js';
 
 const OPTIONS = {
@@ -64,12 +64,15 @@ export async function runCommand(argv) {
       : Array.isArray(config.tools) && config.tools.length
         ? config.tools
         : undefined;
+  const { mode: mcpMode, pinned: mcpPinned } = mcpSettings(store, config);
   const { definitions: toolDefs, execute } = createTools({
     root: cwd,
     enabled,
     permissions: config.permissions,
     yes: Boolean(values.yes),
     mcp,
+    mcpMode,
+    mcpPinned,
   });
 
   let sessionId = values.session;
@@ -108,7 +111,7 @@ export async function runCommand(argv) {
       customProviders,
       systemPrompt: buildSystemPrompt(
         instructions,
-        [values.system, scopeDirective(strict)].filter(Boolean).join('\n\n')
+        [values.system, mcpIndexBlock(mcp, { mode: mcpMode }), scopeDirective(strict)].filter(Boolean).join('\n\n')
       ),
       history,
       input: prompt,

package/harness/packages/cli/src/commands/tui.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { loadConfig, loadInstructions, Store, buildMcpRegistry, resolveMode, scopeDirective } from '../lib/core.js';
 import { parse, databasePath, num } from '../lib/util.js';
-import { buildSystemPrompt, resolveCliProvider } from '../lib/runtime.js';
+import { buildSystemPrompt, resolveCliProvider, mcpSettings, mcpIndexBlock } from '../lib/runtime.js';
 import { runTui } from '../tui/app.js';
 import { color } from '../ui/color.js';
 
@@ -55,6 +55,8 @@ export async function tuiCommand(argv) {
       process.stderr.write(color.yellow(`MCP: ${err.message}\n`));
     }
   }
+  const { mode: mcpMode, pinned: mcpPinned } = mcpSettings(store, config);
+  const mcpBlock = mcpIndexBlock(mcp, { mode: mcpMode });
 
   const baseEnabled = values['no-tools']
     ? []
@@ -69,7 +71,10 @@ export async function tuiCommand(argv) {
   const enabledFor = (m) =>
     m.tools ? (baseEnabled ? baseEnabled.filter((tool) => m.tools.includes(tool)) : m.tools) : baseEnabled;
   const promptFor = (m) =>
-    buildSystemPrompt(instructions, [values.system, m.systemPrompt, scopeDirective(strict)].filter(Boolean).join('\n\n'));
+    buildSystemPrompt(
+      instructions,
+      [values.system, m.systemPrompt, mcpBlock, scopeDirective(strict)].filter(Boolean).join('\n\n')
+    );
   const modeContext = (id) => {
     const m = resolveMode(id);
     return { label: m.label, enabled: enabledFor(m), systemPrompt: promptFor(m) };
@@ -101,6 +106,8 @@ export async function tuiCommand(argv) {
       enabled: enabledFor(mode),
       permissions: config.permissions,
       mcp,
+      mcpMode,
+      mcpPinned,
       yes: Boolean(values.yes),
     },
     store,

package/harness/packages/cli/src/lib/runtime.js

@@ -1,4 +1,26 @@
-import { runAgent, resolveProviderRuntime, composeProviderSettings, resolveApiKey } from './core.js';
+import { runAgent, resolveProviderRuntime, composeProviderSettings, resolveApiKey, useLazyMcp, buildMcpIndex, MCP_AUTO_THRESHOLD } from './core.js';
+
+const MCP_MODES = new Set(['auto', 'eager', 'lazy']);
+
+/** Modo y tools fijadas de MCP (setting de la base, con fallback a tamnora.json). */
+export function mcpSettings(store, config = {}) {
+  const raw = String(store.getSetting('mcpMode') ?? config.mcpMode ?? 'auto');
+  const mode = MCP_MODES.has(raw) ? raw : 'auto';
+  const stored = store.getSetting('mcpPinned');
+  const pinned = Array.isArray(stored)
+    ? stored.map(String)
+    : Array.isArray(config.mcpPinned)
+      ? config.mcpPinned.map(String)
+      : [];
+  return { mode, pinned };
+}
+
+/** Bloque de indice de MCP para el prompt (vacio si el modo es completo). */
+export function mcpIndexBlock(mcp, { mode = 'auto' } = {}) {
+  const total = mcp?.definitions?.length ?? 0;
+  if (!total || !useLazyMcp(mode, total, MCP_AUTO_THRESHOLD)) return '';
+  return buildMcpIndex(mcp.tools ?? []);
+}
 
 /**
  * Resolve provider/model/apiKey/baseUrl for CLI commands, merging the active

package/harness/packages/cli/test/tunnel.test.js

@@ -1,6 +1,6 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { parseTunnelmoleUrls, parseTailscaleStatus, startTunnel } from '../src/lib/tunnel.js';
+import { parseTunnelmoleUrls, parseTailscaleStatus, startTunnel, tailscalePreviewUrl } from '../src/lib/tunnel.js';
 import { qrTerminal } from '../src/lib/qr.js';
 
 test('parseTunnelmoleUrls extracts the https URL', () => {
@@ -32,6 +32,18 @@ test('startTunnel rechaza el proveedor retirado (relay)', async () => {
   await assert.rejects(() => startTunnel(4517, 'relay'), /no soportado/);
 });
 
+test('startTunnel con provider none no abre nada', async () => {
+  const tun = await startTunnel(4517, 'none', { preview: true });
+  assert.equal(tun.provider, 'none');
+  assert.equal(tun.url, '');
+});
+
+test('tailscalePreviewUrl usa el 8443 y omite el 443', () => {
+  assert.equal(tailscalePreviewUrl('pc.tailnet.ts.net'), 'https://pc.tailnet.ts.net:8443');
+  assert.equal(tailscalePreviewUrl('pc.tailnet.ts.net', 9000), 'https://pc.tailnet.ts.net:9000');
+  assert.equal(tailscalePreviewUrl('pc.tailnet.ts.net', 443), 'https://pc.tailnet.ts.net');
+});
+
 test('qrTerminal renders a block matrix for a URL', () => {
   const art = qrTerminal('https://abc-123.tunnelmole.net', 1);
   assert.ok(art.length > 0);

package/harness/packages/core/src/agent/modes.js

@@ -23,6 +23,9 @@ export const MODES = {
       'screenshot',
       'console_errors',
       'preview_url',
+      'ask_user',
+      'offer_choices',
+      'show_plan',
       'git_status',
       'git_diff',
       'git_log',

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

@@ -21,9 +21,11 @@ export const DEFAULT_CONFIG = {
   tools: [],
   permissions: {},
   mcp: [],
+  mcpMode: 'auto',
+  mcpPinned: [],
   server: { host: '127.0.0.1', port: 4517 },
   processes: { enabled: true, allow: [] },
-  preview: { provider: 'tunnelmole' },
+  preview: { provider: 'tailscale', tailscalePort: 8443, fallback: true },
   telegram: { token: '', allowedChatIds: [] },
   agents: { maxRounds: 6 },
 };

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

@@ -4,6 +4,8 @@ export {
   redactDeep,
   secretValues,
   isSecretName,
+  isSensitiveEnvName,
+  scrubEnv,
   maskSecret,
   maskEnv,
   REDACTED,
@@ -77,8 +79,15 @@ export {
   TOOL_NAMES,
   DEFAULT_PERMISSIONS,
   evaluatePermission,
+  bashGuard,
   resolveInRoot,
   toRel,
+  MCP_ROUTER_NAME,
+  MCP_AUTO_THRESHOLD,
+  useLazyMcp,
+  buildMcpIndex,
+  mcpRouterDefinition,
+  planMcpTools,
 } from './tools/index.js';
 export { Store, openDatabase } from './storage/sqlite.js';
 export { runTask } from './eval/runTask.js';
@@ -96,7 +105,8 @@ export {
   buildSkillsPrompt,
   buildSkillsIndex,
 } from './skills/index.js';
-export { parseSkillRef, fetchSkillFromGithub } from './skills/remote.js';
+export { parseSkillRef, fetchSkillFromGithub, searchSkillsGithub } from './skills/remote.js';
+export { SKILLS_CATALOG, skillCatalogEntry } from './skills/catalog.js';
 export {
   MEMORY_DIR,
   MEMORY_INDEX_NAME,
@@ -130,16 +140,20 @@ export {
   searchMcpRegistry,
   getMcpRegistryServer,
   registryServerToConfig,
+  registryServerToCandidate,
   normalizeMcpConfig,
 } from './mcp/registry.js';
+export { MCP_CATALOG, mcpCatalogEntry } from './mcp/catalog.js';
 export {
   parseTunnelmoleUrls,
   parseTailscaleStatus,
   probeTailscale,
   resetTailscaleServe,
   startTailscaleServe,
+  startTailscalePreview,
   startTunnelmole,
   startTunnel,
+  tailscalePreviewUrl,
   tunnelState,
   tunnelActive,
 } from './tunnel.js';
@@ -157,8 +171,8 @@ export {
 export { reconocerGoogle, wavToPcm } from './stt/google.js';
 export { pidAlive, killPidTree } from './pid.js';
 export { openBrowser, openerFor } from './open.js';
-export { detectProcs, packageManager, DEFAULT_PROCESS_ALLOW, staticServerChip } from './procs/detect.js';
-export { killPort } from './procs/kill.js';
+export { detectProcs, loadProjectProcs, packageManager, DEFAULT_PROCESS_ALLOW, staticServerChip, PROCS_FILE } from './procs/detect.js';
+export { killPort, portInfo, pidsOnPort } from './procs/kill.js';
 export {
   ROOT_PACKAGE_NAME,
   readPackageVersion,

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

@@ -0,0 +1,79 @@
+// Catalogo curado de servidores MCP sugeridos. No se instalan solos: la consola
+// (o el agente) los agrega deshabilitados y el usuario decide habilitarlos.
+// Los `env` con valor "env:VAR" se resuelven desde el entorno al arrancar el MCP.
+
+export const MCP_CATALOG = [
+  {
+    id: 'playwright',
+    name: 'Playwright (navegador)',
+    description:
+      'Automatiza un navegador real: webs con JavaScript, formularios y scraping. Complementa las tools screenshot/console_errors.',
+    type: 'stdio',
+    command: 'npx',
+    args: ['-y', '@playwright/mcp@latest'],
+    enabled: false,
+  },
+  {
+    id: 'fetch',
+    name: 'Fetch (webs con JS)',
+    description: 'Trae cualquier URL y la convierte a texto, incluidas las que renderizan con JavaScript. Requiere uv.',
+    type: 'stdio',
+    command: 'uvx',
+    args: ['mcp-server-fetch'],
+    enabled: false,
+  },
+  {
+    id: 'github',
+    name: 'GitHub',
+    description: 'Repos, issues, PRs y búsqueda en GitHub. Necesita un token personal.',
+    type: 'stdio',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-github'],
+    env: { GITHUB_PERSONAL_ACCESS_TOKEN: 'env:GITHUB_PERSONAL_ACCESS_TOKEN' },
+    requiredEnv: ['GITHUB_PERSONAL_ACCESS_TOKEN'],
+    enabled: false,
+  },
+  {
+    id: 'memory',
+    name: 'Memory (grafo)',
+    description: 'Memoria de conocimiento persistente: entidades y relaciones que sobreviven entre sesiones.',
+    type: 'stdio',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-memory'],
+    enabled: false,
+  },
+  {
+    id: 'sequential-thinking',
+    name: 'Sequential Thinking',
+    description: 'Razonamiento paso a paso para descomponer problemas complejos.',
+    type: 'stdio',
+    command: 'npx',
+    args: ['-y', '@modelcontextprotocol/server-sequential-thinking'],
+    enabled: false,
+  },
+  {
+    id: 'sqlite',
+    name: 'SQLite',
+    description: 'Consulta una base SQLite. Reemplazá la ruta por tu archivo .db. Requiere uv.',
+    type: 'stdio',
+    command: 'uvx',
+    args: ['mcp-server-sqlite', '--db-path', 'ruta/a/base.db'],
+    enabled: false,
+  },
+  {
+    id: 'time',
+    name: 'Time',
+    description: 'Hora actual y conversión de zonas horarias. Requiere uv.',
+    type: 'stdio',
+    command: 'uvx',
+    args: ['mcp-server-time'],
+    enabled: false,
+  },
+];
+
+/** Entrada del catalogo por id, como copia (siempre deshabilitada). */
+export function mcpCatalogEntry(id) {
+  const entry = MCP_CATALOG.find((item) => item.id === id);
+  if (!entry) return null;
+  return { ...entry, args: [...(entry.args ?? [])], env: entry.env ? { ...entry.env } : undefined, enabled: false };
+}

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

@@ -70,12 +70,19 @@ export async function buildMcpRegistry(servers = [], { signal } = {}) {
 
   const map = new Map();
   const definitions = [];
+  const tools = [];
   const sessions = [];
   const errors = [];
 
-  const add = (name, definition, call) => {
+  const add = (server, name, definition, call) => {
     map.set(name, call);
     definitions.push(definition);
+    tools.push({
+      name,
+      server: server.id,
+      serverName: server.name ?? server.id,
+      description: definition.function?.description ?? '',
+    });
   };
 
   for (const r of results) {
@@ -101,19 +108,21 @@ export async function buildMcpRegistry(servers = [], { signal } = {}) {
 
     for (const tool of session.tools ?? []) {
       const name = qualifiedToolName(server.id, tool.name);
-      add(name, mcpToolToDefinition(tool, server, name), async (args) => (await reconnect()).callTool(tool.name, args));
+      add(server, name, mcpToolToDefinition(tool, server, name), async (args) => (await reconnect()).callTool(tool.name, args));
     }
 
     if (session.capabilities?.resources || session.resources?.length) {
       const label = server.name ?? server.id;
       const listName = qualifiedToolName(server.id, 'list_resources');
       add(
+        server,
         listName,
         syntheticDefinition(listName, `Lista los recursos MCP del servidor ${label}.`),
         async () => formatResources(await (await reconnect()).listResources())
       );
       const readName = qualifiedToolName(server.id, 'read_resource');
       add(
+        server,
         readName,
         syntheticDefinition(readName, `Lee un recurso MCP del servidor ${label} a partir de su uri.`, {
           type: 'object',
@@ -128,12 +137,14 @@ export async function buildMcpRegistry(servers = [], { signal } = {}) {
       const label = server.name ?? server.id;
       const listName = qualifiedToolName(server.id, 'list_prompts');
       add(
+        server,
         listName,
         syntheticDefinition(listName, `Lista los prompts MCP del servidor ${label}.`),
         async () => formatPrompts(await (await reconnect()).listPrompts())
       );
       const getName = qualifiedToolName(server.id, 'get_prompt');
       add(
+        server,
         getName,
         syntheticDefinition(getName, `Obtiene un prompt MCP del servidor ${label}.`, {
           type: 'object',
@@ -150,6 +161,7 @@ export async function buildMcpRegistry(servers = [], { signal } = {}) {
 
   return {
     definitions,
+    tools,
     sessions,
     errors,
     resources: sessions.flatMap((s) => s.resources ?? []),