@danieltmn/tamnora 0.17.0 → 0.19.0

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;
@@ -421,11 +422,11 @@ const MAX_SPEAK_TEXT = 1200;
  * son del cliente (la consola lo reproduce y Telegram lo manda como nota de
  * voz), asi que aca solo se normaliza el pedido y se acota el largo.
  */
-export function speakTool(_root, { texto, voice, rate } = {}) {
+export function speakTool(_root, { texto, voice, rate, pitch } = {}) {
   const value = String(texto ?? '').replace(/\s+/g, ' ').trim();
   if (!value) return 'Error: falta "texto".';
   const recortado = value.length > MAX_SPEAK_TEXT ? `${value.slice(0, MAX_SPEAK_TEXT - 1).trimEnd()}…` : value;
-  const opciones = [voice, rate].filter(Boolean).join(', ');
+  const opciones = [voice, rate, pitch].filter(Boolean).join(', ');
   return `Audio pedido${opciones ? ` (${opciones})` : ''}: "${recortado}". El cliente lo reproduce o lo envía como nota de voz.`;
 }
 
@@ -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 };
+}

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

@@ -17,6 +17,9 @@ export const DEFAULT_PERMISSIONS = {
   screenshot: 'allow',
   console_errors: 'allow',
   preview_url: 'allow',
+  ask_user: 'allow',
+  offer_choices: 'allow',
+  show_plan: 'allow',
   write: 'ask',
   edit: 'ask',
   bash: 'ask',
@@ -50,27 +53,69 @@ function subjectFor(name, args) {
   return args?.path ?? '';
 }
 
+// Guardas de `bash`: comandos catastroficos o irreversibles que no deberian
+// colarse aunque la policy sea `allow` (o `--yes`). `deny` = nunca legitimo;
+// `ask` = nunca se autoaprueba (siempre consulta, aunque bash sea `allow`).
+const BASH_DENY = [
+  /:\s*\(\s*\)\s*\{[\s\S]*\}\s*;?\s*:/, // fork bomb :(){ :|:& };:
+  /\brm\s+(-[a-z]*r[a-z]*f|-[a-z]*f[a-z]*r)(\s+--?[\w-]+)*\s+(\/|~|\$HOME|\/\*)(\s|$)/i,
+  /\bmkfs(\.|\s|$)/i,
+  /\bdd\b[^\n]*\bof=\/dev\//i,
+  />\s*\/dev\/(sd|nvme|disk)/i,
+  /\bchmod\s+-R\s+777\s+\/(\s|$)/i,
+  /\b(?:format|del|erase|rd|rmdir)\b[^\n]*\b[a-z]:[\\/]\*/i, // Windows: borrar/formatear unidad
+  /\b(?:remove-item|del|rd|rmdir|format)\b[^\n]*(?:-recurse|-r\b)[^\n]*\b[a-z]:\\?\s*$/i,
+];
+const BASH_ASK = [
+  /\brm\s+(-[a-z]*r[a-z]*f|-[a-z]*f[a-z]*r)(\s+--?[\w-]+)*\s+(\*|\.|\.\/)(\s|$)/i, // rm -rf * | . (workspace)
+  /\bgit\s+push\b[^\n]*(\s-f\b|\s--force\b)/i,
+  /\bgit\s+reset\s+--hard\b/i,
+  /\bgit\s+clean\s+-[a-z]*f/i,
+];
+
+/** Devuelve `'deny'`/`'ask'` si el comando es peligroso, o `null`. */
+export function bashGuard(command) {
+  const text = String(command ?? '');
+  if (!text.trim()) return null;
+  for (const re of BASH_DENY) if (re.test(text)) return 'deny';
+  for (const re of BASH_ASK) if (re.test(text)) return 'ask';
+  return null;
+}
+
+const RANK = { allow: 0, ask: 1, deny: 2 };
+
 /**
  * Decide the permission for a tool call.
  * @returns {'allow'|'ask'|'deny'}
  */
 export function evaluatePermission(name, args = {}, permissions = {}) {
   const value = permissions[name] ?? DEFAULT_PERMISSIONS[name] ?? 'ask';
+  let decision = 'ask';
 
-  if (typeof value === 'string') return value;
-
-  if (value && typeof value === 'object') {
+  if (typeof value === 'string') {
+    decision = value;
+  } else if (value && typeof value === 'object') {
     const subject = subjectFor(name, args);
     let fallback = 'ask';
-    for (const [pattern, decision] of Object.entries(value)) {
+    let matched = false;
+    for (const [pattern, d] of Object.entries(value)) {
       if (pattern === '*') {
-        fallback = decision;
+        fallback = d;
         continue;
       }
-      if (matchPattern(pattern, subject)) return decision;
+      if (matchPattern(pattern, subject)) {
+        decision = d;
+        matched = true;
+        break;
+      }
     }
-    return fallback;
+    if (!matched) decision = fallback;
   }
 
-  return 'ask';
+  // Piso de seguridad: un comando peligroso no se puede autoaprobar por policy.
+  if (name === 'bash') {
+    const guard = bashGuard(args?.command);
+    if (guard && RANK[guard] > RANK[decision]) decision = guard;
+  }
+  return decision;
 }

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

@@ -10,29 +10,35 @@ import { evaluatePermission } from './permissions.js';
  * @param {string[]} [opts.enabled] - tool names to expose (default: all)
  * @param {object} [opts.permissions] - policy per tool ('allow'|'ask'|'deny' or pattern map)
  * @param {(name:string, args:object)=>Promise<boolean>} [opts.onAsk] - interactive approval
+ * @param {(payload:{title:string, questions:object[]})=>Promise<{answers:object,cancelled?:boolean}>} [opts.onQuestion] - interactive form
  * @param {boolean} [opts.yes] - auto-approve 'ask' (non-interactive)
  * @param {AbortSignal} [opts.signal] - cancela las tools de larga duracion (bash, git)
  */
-export function createToolRegistry({ root, enabled, permissions = {}, onAsk, yes = false, signal } = {}) {
+export function createToolRegistry({ root, enabled, permissions = {}, onAsk, onQuestion, yes = false, signal } = {}) {
   const names = new Set(enabled?.length ? enabled : TOOL_NAMES);
   const definitions = TOOL_DEFINITIONS.filter((d) => names.has(d.function.name));
 
-  async function execute(name, args = {}) {
-    if (!names.has(name) || !(name in EXECUTORS)) {
-      return `Error: herramienta desconocida "${name}".`;
-    }
-
+  async function authorize(name, args = {}) {
     let decision = evaluatePermission(name, args, permissions);
     if (decision === 'ask') {
       if (onAsk) decision = (await onAsk(name, args)) ? 'allow' : 'deny';
       else decision = yes ? 'allow' : 'deny';
     }
+    return decision;
+  }
+
+  async function execute(name, args = {}) {
+    if (!names.has(name) || !(name in EXECUTORS)) {
+      return `Error: herramienta desconocida "${name}".`;
+    }
+
+    const decision = await authorize(name, args);
     if (decision === 'deny') {
       const detail = args?.command ?? args?.path ?? '';
       return `Permiso denegado para "${name}"${detail ? ` (${detail})` : ''}.`;
     }
 
-    return EXECUTORS[name](root, args, { signal });
+    return EXECUTORS[name](root, args, { signal, onQuestion });
   }
 
   return {
@@ -40,6 +46,7 @@ export function createToolRegistry({ root, enabled, permissions = {}, onAsk, yes
     definitions,
     names: [...names],
     handles: (name) => names.has(name) && name in EXECUTORS,
+    authorize,
     execute,
   };
 }