@danieltmn/tamnora 0.21.0 → 0.21.2

package/CHANGELOG.md

@@ -5,6 +5,18 @@ 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.21.2] - 2026-10-20
+
+### Cambios
+
+- fix: cierra los P0 de la auditoria y pule la compactacion
+
+## [0.21.1] - 2026-10-16
+
+### Cambios
+
+- feat(config): export/import de la configuracion de la casa
+
 ## [0.21.0] - 2026-10-14
 
 ### Cambios

package/README.md

@@ -29,7 +29,8 @@ con TUI, consola web, tools locales, MCP y evaluacion de modelos.
 - **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`).
+- **Plataforma**: hooks y plugins locales declarados en `tamnora.json`
+  (`.tamnora/hooks`, `.tamnora/plugins`; nunca se cargan por presencia).
 
 ## Instalacion
 
@@ -186,11 +187,14 @@ Los tres se renderizan en vivo y se reconstruyen al recargar la consola.
 
 ### Hooks y plugins
 
-- **Hooks** (`.tamnora/hooks/*.mjs` o `hooks[]`): observan el ciclo de vida
-  (`run.start/end`, `tool.before/after`, `session.compacting/compacted`, `advice`).
-  Corren aislados y con los datos redactados; son opt-in.
-- **Plugins** (`.tamnora/plugins/*.mjs` o `plugins[]`): agregan **tools propias**
-  al agente (expuestas como `plugin__<plugin>__<tool>`, con permisos).
+- **Hooks** (`hooks[]` en `tamnora.json`, p. ej. `[".tamnora/hooks/*.mjs"]`):
+  observan el ciclo de vida (`run.start/end`, `tool.before/after`,
+  `session.compacting/compacted`, `advice`). Corren aislados y con los datos
+  redactados. Es **opt-in explícito**: la presencia de archivos en el proyecto no
+  ejecuta nada.
+- **Plugins** (`plugins[]`, p. ej. `[".tamnora/plugins/*.mjs"]`): agregan **tools
+  propias** al agente (expuestas como `plugin__<plugin>__<tool>`, con permisos).
+  Igual que los hooks, solo se cargan desde la config.
 
 ### Preview
 

package/SECURITY.md

@@ -35,6 +35,19 @@ 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`.
+- **Hooks y plugins**: son **opt-in explicito**. Solo se ejecutan los modulos
+  `.mjs` cuyos patrones declares en `hooks[]`/`plugins[]` de `tamnora.json`; la
+  presencia de `.tamnora/hooks` o `.tamnora/plugins` en un proyecto **no** ejecuta
+  nada. Aun asi, un hook/plugin corre con tus privilegios: revisalo antes de
+  declararlo.
+- **Salidas HTTP**: `fetch_url`, `screenshot` y `console_errors` bloquean loopback,
+  redes privadas, link-local, CGNAT y rangos IPv6 internos (incluido
+  IPv4-mapped), y **revalidan el host en cada redirect**. `preview_url` es la
+  excepcion a proposito: abre URLs locales en el panel de vista previa de la
+  consola.
+- **Procesos de dev**: `POST /api/procs/start` solo acepta conexiones locales,
+  pasa por la allowlist `processes.allow` y valida los argumentos; en Windows no
+  se permiten metacaracteres del shell.
 - **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`,

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

@@ -10,6 +10,7 @@ import { bridgeCommand } from './commands/bridge.js';
 import { updateCommand } from './commands/update.js';
 import { autostartCommand } from './commands/autostart.js';
 import { doctorCommand } from './commands/doctor.js';
+import { configCommand } from './commands/config.js';
 import { tuiCommand } from './commands/tui.js';
 import { ensureUtf8Console } from './lib/util.js';
 import { readPackageVersion } from './lib/core.js';
@@ -29,6 +30,7 @@ const COMMANDS = {
   update: updateCommand,
   autostart: autostartCommand,
   doctor: doctorCommand,
+  config: configCommand,
 };
 
 function readVersion() {
@@ -76,6 +78,7 @@ Uso:
   tamnora autostart install|remove    Arranque automatico del server
   tamnora serve                   Consola web local (primer plano)
   tamnora doctor                  Verificar Node, casa, puerto y base
+  tamnora config export|import    Exportar/importar la configuracion (proveedores + ajustes)
   tamnora update                  Buscar/instalar una version nueva
   tamnora init                    Crear tamnora.json
 

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

@@ -0,0 +1,141 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import {
+  appConfigPath,
+  databasePath,
+  exportConfig,
+  homeDir,
+  importConfig,
+  Store,
+} from '../../../core/src/index.js';
+import { parse } from '../lib/util.js';
+import { applyHomeOverride, stopRunningServer } from '../lib/daemon.js';
+
+const DEFAULT_FILE = 'tamnora-config.json';
+
+const OPTIONS = {
+  home: { type: 'string' },
+  out: { type: 'string', short: 'o' },
+  'with-secrets': { type: 'boolean' },
+  stdout: { type: 'boolean' },
+  'dry-run': { type: 'boolean' },
+  help: { type: 'boolean', short: 'h' },
+};
+
+export async function configCommand(argv) {
+  const { values, positionals } = parse(argv, OPTIONS);
+  if (values.help) {
+    printHelp();
+    return 0;
+  }
+  applyHomeOverride(values);
+
+  const sub = (positionals[0] || 'path').toLowerCase();
+  const target = positionals[1] || values.out;
+
+  if (sub === 'export') return doExport(values, target);
+  if (sub === 'import') return doImport(values, target);
+  if (sub === 'path') {
+    printPaths();
+    return 0;
+  }
+  printHelp();
+  return 1;
+}
+
+function withStore(fn) {
+  const store = new Store(databasePath());
+  try {
+    return fn(store);
+  } finally {
+    store.close();
+  }
+}
+
+function doExport(values, target) {
+  const data = withStore((store) => exportConfig({ store, withSecrets: Boolean(values['with-secrets']) }));
+  const json = `${JSON.stringify(data, null, 2)}\n`;
+  if (values.stdout || target === '-') {
+    process.stdout.write(json);
+    return 0;
+  }
+  const file = path.resolve(target || DEFAULT_FILE);
+  writeFileSync(file, json);
+  console.log(`Configuracion exportada a ${file}`);
+  console.log(`  proveedores: ${data.providers.length}  ·  ajustes: ${Object.keys(data.settings).length}`);
+  console.log(`  secretos: ${data.secrets ? 'incluidos' : 'enmascarados (usa --with-secrets para incluirlos)'}`);
+  return 0;
+}
+
+function doImport(values, target) {
+  if (!target) {
+    console.error('Falta el archivo: tamnora config import <archivo.json>');
+    return 1;
+  }
+  const file = path.resolve(target);
+  let data;
+  try {
+    data = JSON.parse(readFileSync(file, 'utf8'));
+  } catch (error) {
+    console.error(`No pude leer ${file}: ${error.message}`);
+    return 1;
+  }
+
+  const dryRun = Boolean(values['dry-run']);
+  if (!dryRun && stopRunningServer()) {
+    console.log('Habia un server corriendo; lo detuve para aplicar los cambios.');
+  }
+
+  let summary;
+  try {
+    summary = withStore((store) => importConfig(store, data, { dryRun }));
+  } catch (error) {
+    console.error(error.message);
+    return 1;
+  }
+
+  if (dryRun) {
+    console.log('Simulacion (--dry-run): no se cambio nada.');
+    printSummary(summary);
+    return 0;
+  }
+  printSummary(summary);
+  console.log('Volve a arrancar el server: tamnora server --start');
+  return 0;
+}
+
+function printSummary(summary) {
+  console.log(`Importado: ${summary.providers} proveedor(es), ${summary.settings} ajuste(s), app.json actualizado.`);
+  if (summary.missingKeys.length) {
+    console.log(`  Ojo: ${summary.missingKeys.join(', ')} quedaron sin API key (venian enmascaradas); cargalas en la consola.`);
+  }
+}
+
+function printPaths() {
+  console.log(`Casa de Tamnora : ${homeDir()}`);
+  console.log(`  config app    : ${appConfigPath()}`);
+  console.log(`  base de datos : ${databasePath()}`);
+  console.log('  por proyecto  : <cwd>/tamnora.json y <cwd>/.tamnora/');
+}
+
+function printHelp() {
+  console.log(`Uso: tamnora config <export|import|path> [archivo] [opciones]
+
+Exporta o importa la configuracion de la casa (app.json + proveedores + ajustes).
+No incluye sesiones, historial, MCP servers ni tareas programadas.
+
+  export [archivo]     Vuelca la configuracion a JSON (default: ${DEFAULT_FILE})
+  import <archivo>     Aplica el JSON sobre esta instalacion
+  path                 Muestra donde vive la configuracion
+
+Opciones:
+  --with-secrets       Incluye API keys y secretos reales (default: enmascarados)
+  -o, --out <archivo>  Archivo de salida para export
+  --stdout             Imprime el JSON por stdout (export)
+  --dry-run            Muestra que haria el import sin escribir nada
+  --home <path>        Casa de Tamnora (default: TAMNORA_HOME o datos del sistema)
+
+Ejemplos:
+  tamnora config export tamnora-config.json --with-secrets
+  tamnora config import tamnora-config.json`);
+}

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

@@ -8,6 +8,7 @@ import { spawn } from 'node:child_process';
 import { existsSync, mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
+import { isBlockedHost, normalizeHost } from '../net/hosts.js';
 
 const LAUNCH_TIMEOUT_MS = 15000;
 
@@ -52,6 +53,31 @@ function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+function assertAllowedUrl(raw) {
+  let parsed;
+  try {
+    parsed = new URL(String(raw));
+  } catch {
+    throw new Error(`URL inválida: ${raw}`);
+  }
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+    throw new Error(`Solo se admite http(s): ${raw}`);
+  }
+  if (isBlockedHost(parsed.hostname)) {
+    throw new Error(`host bloqueado (${normalizeHost(parsed.hostname)}).`);
+  }
+}
+
+function isBlockedNavigation(raw) {
+  try {
+    const parsed = new URL(String(raw));
+    if (!parsed.hostname) return parsed.protocol === 'file:';
+    return isBlockedHost(parsed.hostname);
+  } catch {
+    return false;
+  }
+}
+
 function launchBrowser(bin) {
   return new Promise((resolve, reject) => {
     const profile = mkdtempSync(path.join(tmpdir(), 'tamnora-browser-'));
@@ -209,8 +235,35 @@ async function openPage(wsUrl, url, { timeoutMs = 20000, collectMessages = true
       }
     });
   });
-  await cdp.send('Page.navigate', { url }, sessionId);
-  await Promise.race([loaded, delay(timeoutMs)]);
+  let blockedUrl = '';
+  const offNav = cdp.on((message) => {
+    if (message.method !== 'Page.frameNavigated' || message.sessionId !== sessionId) return;
+    const frame = message.params?.frame;
+    if (!frame || frame.parentId || !frame.url || frame.url === 'about:blank') return;
+    if (isBlockedNavigation(frame.url)) blockedUrl = frame.url;
+  });
+  try {
+    await cdp.send('Page.navigate', { url }, sessionId);
+    await Promise.race([loaded, delay(timeoutMs)]);
+  } finally {
+    offNav();
+  }
+  if (!blockedUrl) {
+    try {
+      const { result } = await cdp.send(
+        'Runtime.evaluate',
+        { expression: 'location.href', returnByValue: true },
+        sessionId
+      );
+      const finalUrl = String(result?.value ?? '');
+      if (finalUrl && isBlockedNavigation(finalUrl)) blockedUrl = finalUrl;
+    } catch {
+      /* sin runtime disponible: nos quedamos con los eventos de navegacion */
+    }
+  }
+  if (blockedUrl) {
+    throw new Error(`host bloqueado (${normalizeHost(new URL(blockedUrl).hostname)}).`);
+  }
 
   return { cdp, sessionId, targetId, messages };
 }
@@ -234,6 +287,7 @@ function killBrowser(child) {
 }
 
 async function withBrowser(url, options, run) {
+  assertAllowedUrl(url);
   const bin = findBrowserPath();
   if (!bin) {
     throw new Error('no encontré Chrome/Edge/Chromium; definí TAMNORA_BROWSER con la ruta al ejecutable');

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

@@ -0,0 +1,138 @@
+import { readApp, writeApp } from './app.js';
+
+/**
+ * Export/import portable de la configuracion de la casa (app.json + tablas
+ * `providers` y `settings` de la base global). Los secretos (API keys, hash de
+ * usuario, token de Telegram, `authSecret`) se enmascaran salvo `withSecrets`;
+ * al importar, los valores enmascarados se saltan y se conserva lo existente.
+ */
+
+export const CONFIG_KIND = 'tamnora-config';
+export const CONFIG_VERSION = 1;
+export const MASKED = '<<tamnora:secreto>>';
+
+const LINKAGE_PREFIXES = ['telegram:', 'scheduleSession:'];
+
+function isSecretValue(value) {
+  return typeof value === 'string' && value !== '' && !value.startsWith('env:');
+}
+
+function isLinkageKey(key) {
+  return LINKAGE_PREFIXES.some((prefix) => key.startsWith(prefix));
+}
+
+function maskApp(app) {
+  const out = structuredClone(app);
+  if (isSecretValue(out.authSecret)) out.authSecret = MASKED;
+  if (out.user) out.user = MASKED;
+  if (out.telegram && isSecretValue(out.telegram.token)) out.telegram.token = MASKED;
+  if (out.tunnel && isSecretValue(out.tunnel.token)) out.tunnel.token = MASKED;
+  return out;
+}
+
+function providerToPortable(provider, withSecrets) {
+  const apiKey = withSecrets || !isSecretValue(provider.apiKey) ? provider.apiKey ?? '' : MASKED;
+  return {
+    id: provider.id,
+    label: provider.label,
+    baseUrl: provider.baseUrl ?? '',
+    apiKey,
+    models: provider.models ?? [],
+    requiresKey: provider.requiresKey,
+    custom: Boolean(provider.custom),
+    enabled: provider.enabled !== false,
+  };
+}
+
+function exportableSettings(all) {
+  const out = {};
+  for (const [key, value] of Object.entries(all)) {
+    if (isLinkageKey(key)) continue;
+    out[key] = value;
+  }
+  return out;
+}
+
+function normalizePayload(data) {
+  if (!data || typeof data !== 'object') {
+    throw new Error('El archivo no es un objeto JSON valido.');
+  }
+  if (data.kind !== CONFIG_KIND) {
+    throw new Error(`No parece un export de Tamnora (kind: ${data.kind ?? 'desconocido'}).`);
+  }
+  if (Number(data.version) > CONFIG_VERSION) {
+    throw new Error(`Version de export no soportada: ${data.version} (max ${CONFIG_VERSION}).`);
+  }
+  return data;
+}
+
+function mergeMaskAware(target, source) {
+  for (const [key, value] of Object.entries(source)) {
+    if (value === MASKED) continue;
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+      const base = target[key] && typeof target[key] === 'object' && !Array.isArray(target[key]) ? target[key] : {};
+      target[key] = mergeMaskAware({ ...base }, value);
+    } else {
+      target[key] = value;
+    }
+  }
+  return target;
+}
+
+/** Arma el payload portable a partir del store y `app.json`. */
+export function exportConfig({ store, withSecrets = false, now } = {}) {
+  const app = readApp();
+  return {
+    kind: CONFIG_KIND,
+    version: CONFIG_VERSION,
+    exportedAt: new Date(now ?? Date.now()).toISOString(),
+    secrets: withSecrets,
+    app: withSecrets ? app : maskApp(app),
+    providers: store.listProviders().map((provider) => providerToPortable(provider, withSecrets)),
+    settings: exportableSettings(store.allSettings()),
+  };
+}
+
+/**
+ * Aplica un payload portable sobre el store y `app.json`. Con `dryRun` no
+ * escribe nada. Devuelve un resumen (proveedores, ajustes y claves faltantes).
+ */
+export function importConfig(store, data, { dryRun = false } = {}) {
+  const payload = normalizePayload(data);
+  const summary = { app: true, providers: 0, settings: 0, missingKeys: [] };
+
+  const app = readApp();
+  mergeMaskAware(app, payload.app ?? {});
+
+  for (const provider of payload.providers ?? []) {
+    if (!provider?.id) continue;
+    const existing = store.getProvider(provider.id);
+    let apiKey = provider.apiKey ?? '';
+    if (apiKey === MASKED) {
+      apiKey = existing?.apiKey ?? '';
+      if (!apiKey) summary.missingKeys.push(provider.id);
+    }
+    if (!dryRun) {
+      store.saveProvider({
+        id: provider.id,
+        label: provider.label,
+        baseUrl: provider.baseUrl,
+        apiKey,
+        models: provider.models,
+        requiresKey: provider.requiresKey,
+        custom: provider.custom,
+        enabled: provider.enabled !== false,
+      });
+    }
+    summary.providers += 1;
+  }
+
+  for (const [key, value] of Object.entries(payload.settings ?? {})) {
+    if (isLinkageKey(key)) continue;
+    if (!dryRun) store.setSetting(key, value);
+    summary.settings += 1;
+  }
+
+  if (!dryRun) writeApp(app);
+  return summary;
+}

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

@@ -1,7 +1,9 @@
 // Hooks locales: modulos `.mjs` que observan el ciclo de vida del agente
-// (cargados con `import()` dinamico, opt-in por presencia y aislados de errores).
-// Un hook exporta por default un objeto `{ name?, events: { '<tipo>': fn } }` o
-// una funcion (se llama para todos los eventos).
+// (cargados con `import()` dinamico). Es **opt-in explicito**: solo se cargan
+// los patrones declarados en `config.hooks[]`; la mera presencia de archivos en
+// el cwd no ejecuta nada. Un hook exporta por default un objeto
+// `{ name?, events: { '<tipo>': fn } }` o una funcion (se llama para todos los
+// eventos).
 
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
@@ -23,11 +25,13 @@ export function normalizeHookModule(mod, id = '') {
 }
 
 /**
- * Carga los hooks de `patterns` + `.tamnora/hooks/*.mjs` (relativos a `cwd`).
+ * Carga los hooks de los `patterns` explicitos (relativos a `cwd`). Sin
+ * patrones no se importa nada: abrir un proyecto no ejecuta codigo por si solo.
  * Un modulo roto se ignora.
  */
 export async function loadHooks(cwd, patterns = []) {
-  const list = [...new Set([...(patterns ?? []), ...DEFAULT_HOOK_PATTERNS])];
+  const list = [...new Set(patterns ?? [])];
+  if (!list.length) return [];
   const hooks = [];
   for (const rel of await globFiles(cwd, list)) {
     try {

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

@@ -70,6 +70,7 @@ export {
   migrateLegacyDb,
 } from './config/home.js';
 export { DEFAULT_APP, readApp, writeApp, ensureApp, randomToken } from './config/app.js';
+export { exportConfig, importConfig, CONFIG_KIND, CONFIG_VERSION, MASKED } from './config/portable.js';
 export { hashPassword, verifyPassword, userValidName, makeUser } from './config/identity.js';
 export { composeProviderSettings } from './config/providers.js';
 export {

package/harness/packages/core/src/net/hosts.js

@@ -0,0 +1,111 @@
+// Guarda de hosts para salidas del harness: bloquea loopback, redes privadas,
+// link-local, CGNAT y rangos IPv6 internos (incluido IPv4-mapped). La usan
+// `fetch_url` (tambien en cada redirect) y el navegador headless.
+
+import net from 'node:net';
+
+const BLOCKED_SUFFIXES = ['.localhost', '.local', '.internal', '.intranet', '.lan', '.home.arpa'];
+
+export function normalizeHost(hostname) {
+  return String(hostname ?? '')
+    .toLowerCase()
+    .replace(/^\[|\]$/g, '')
+    .replace(/\.$/, '');
+}
+
+function isBlockedV4(octets) {
+  const [a, b] = octets;
+  if (!Number.isInteger(a) || !Number.isInteger(b)) return true;
+  if (a === 0 || a === 10 || a === 127) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  if (a >= 224) return true;
+  return false;
+}
+
+function parseV4(value) {
+  const parts = String(value).split('.').map(Number);
+  if (parts.length !== 4 || parts.some((n) => !Number.isInteger(n) || n < 0 || n > 255)) return null;
+  return parts;
+}
+
+function parseV6(value) {
+  let text = String(value).toLowerCase().split('%')[0];
+  const embedded = /(\d{1,3}(?:\.\d{1,3}){3})$/.exec(text);
+  if (embedded) {
+    const v4 = parseV4(embedded[1]);
+    if (!v4) return null;
+    const hex = `${((v4[0] << 8) | v4[1]).toString(16)}:${((v4[2] << 8) | v4[3]).toString(16)}`;
+    text = text.slice(0, text.length - embedded[1].length) + hex;
+  }
+  const halves = text.split('::');
+  if (halves.length > 2) return null;
+  const left = halves[0] ? halves[0].split(':') : [];
+  const right = halves.length === 2 && halves[1] ? halves[1].split(':') : [];
+  const missing = 8 - left.length - right.length;
+  if (halves.length === 1 ? missing !== 0 : missing < 0) return null;
+  const groups = [...left, ...Array(halves.length === 2 ? missing : 0).fill('0'), ...right];
+  if (groups.length !== 8) return null;
+  const parsed = groups.map((group) => (/^[0-9a-f]{1,4}$/.test(group) ? parseInt(group, 16) : NaN));
+  return parsed.some(Number.isNaN) ? null : parsed;
+}
+
+function isBlockedV6(groups) {
+  if (!groups) return true;
+  const [g0, g1, g2, g3, g4, g5, g6, g7] = groups;
+  if (groups.every((g) => g === 0)) return true; // ::
+  if (g0 === 0 && g1 === 0 && g2 === 0 && g3 === 0 && g4 === 0 && g5 === 0 && g6 === 0 && g7 === 1) {
+    return true; // ::1
+  }
+  if ((g0 & 0xfe00) === 0xfc00) return true; // fc00::/7
+  if ((g0 & 0xffc0) === 0xfe80) return true; // fe80::/10
+  if ((g0 & 0xff00) === 0xff00) return true; // multicast
+  if (g0 === 0x64 && g1 === 0xff9b && g2 === 0 && g3 === 0 && g4 === 0 && g5 === 0) {
+    return isBlockedV4([g6 >> 8, g6 & 0xff, g7 >> 8, g7 & 0xff]); // 64:ff9b::/96
+  }
+  if (g0 === 0 && g1 === 0 && g2 === 0 && g3 === 0 && g4 === 0 && (g5 === 0 || g5 === 0xffff)) {
+    return isBlockedV4([g6 >> 8, g6 & 0xff, g7 >> 8, g7 & 0xff]); // IPv4-compatible / mapped
+  }
+  return false;
+}
+
+/** `true` si la IP (v4 o v6) es loopback, privada, link-local o reservada. */
+export function isBlockedAddress(address) {
+  const value = normalizeHost(address);
+  const family = net.isIP(value);
+  if (family === 4) return isBlockedV4(parseV4(value) ?? []);
+  if (family === 6) return isBlockedV6(parseV6(value));
+  return true;
+}
+
+/** `true` si el hostname (o literal IP) no debe usarse para salir del harness. */
+export function isBlockedHost(hostname) {
+  const host = normalizeHost(hostname);
+  if (!host) return true;
+  if (net.isIP(host)) return isBlockedAddress(host);
+  if (host === 'localhost' || host === 'localhost.localdomain') return true;
+  if (BLOCKED_SUFFIXES.some((suffix) => host.endsWith(suffix))) return true;
+  if (!host.includes('.')) return true; // una sola etiqueta suele ser un host interno
+  return false;
+}
+
+/** Valida una URL http(s) para una salida del harness. */
+export function checkHttpUrl(value) {
+  const raw = String(value ?? '').trim();
+  if (!raw) return { error: 'falta "url".' };
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    return { error: `URL inválida: "${raw}".` };
+  }
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+    return { error: 'Solo se admite http(s).' };
+  }
+  if (isBlockedHost(parsed.hostname)) {
+    return { error: `host bloqueado (${normalizeHost(parsed.hostname)}).` };
+  }
+  return { url: parsed.toString(), parsed };
+}

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

@@ -1,7 +1,8 @@
 // Plugins locales: modulos `.mjs` que exportan `{ name?, tools: [...] }` para
 // agregar herramientas propias al agente. Se cargan con `import()` dinamico,
-// opt-in por presencia. Cada tool: `{ name, description, parameters?, required?,
-// handler(args, ctx) }`.
+// **opt-in explicito**: solo los patrones declarados en `config.plugins[]`; la
+// presencia de archivos en el cwd no ejecuta nada. Cada tool:
+// `{ name, description, parameters?, required?, handler(args, ctx) }`.
 
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
@@ -19,9 +20,10 @@ export function normalizePlugin(mod, id = '') {
   return { id: value.name || id, tools: valid };
 }
 
-/** Carga los plugins de `patterns` + `.tamnora/plugins/*.mjs`. */
+/** Carga los plugins de los `patterns` explicitos (relativos a `cwd`). */
 export async function loadPlugins(cwd, patterns = []) {
-  const list = [...new Set([...(patterns ?? []), ...DEFAULT_PLUGIN_PATTERNS])];
+  const list = [...new Set(patterns ?? [])];
+  if (!list.length) return [];
   const plugins = [];
   for (const rel of await globFiles(cwd, list)) {
     try {