@danieltmn/tamnora 0.14.0 → 0.15.0

package/CHANGELOG.md

@@ -5,6 +5,21 @@ 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.15.0] - 2026-10-10
+
+### Agregado
+
+- **Fase 4 del roadmap del server (plataforma)**:
+  - **Hooks locales**: módulos `.mjs` en `.tamnora/hooks/*.mjs` (o `hooks[]` en
+    `tamnora.json`) que observan el ciclo de vida (`run.start/end`,
+    `tool.before/after`, `session.compacting/compacted`, `advice`). Aislados de
+    errores, con datos redactados, opt-in.
+  - **Plugins**: módulos `.mjs` en `.tamnora/plugins/*.mjs` (o `plugins[]`) que
+    agregan **tools propias** al agente (`plugin__<plugin>__<tool>`), sujetas a
+    permisos (default `ask`).
+  - **Asesor con proveedor/modelo propios**: `app.json -> advisor`
+    `provider`/`model`; si están vacíos usa los activos.
+
 ## [0.14.0] - 2026-10-10
 
 ### Agregado

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

@@ -16,6 +16,8 @@ export const DEFAULT_CONFIG = {
   compact: { enabled: true, threshold: 0.75, keepLast: 8 },
   rules: ['.tamnora/rules/*.md'],
   memory: { enabled: true },
+  hooks: [],
+  plugins: [],
   tools: [],
   permissions: {},
   mcp: [],

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

@@ -0,0 +1,42 @@
+// 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).
+
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { globFiles } from '../tools/glob.js';
+
+export const DEFAULT_HOOK_PATTERNS = ['.tamnora/hooks/*.mjs'];
+
+/** Normaliza el modulo de un hook a `{ id, events }` (o null si no es valido). */
+export function normalizeHookModule(mod, id = '') {
+  const value = mod?.default ?? mod;
+  if (typeof value === 'function') return { id, events: { '*': value } };
+  if (value && typeof value === 'object' && value.events && typeof value.events === 'object') {
+    return { id: value.name || id, events: value.events };
+  }
+  if (value && typeof value === 'object' && typeof value.onEvent === 'function') {
+    return { id: value.name || id, events: { '*': value.onEvent } };
+  }
+  return null;
+}
+
+/**
+ * Carga los hooks de `patterns` + `.tamnora/hooks/*.mjs` (relativos a `cwd`).
+ * Un modulo roto se ignora.
+ */
+export async function loadHooks(cwd, patterns = []) {
+  const list = [...new Set([...(patterns ?? []), ...DEFAULT_HOOK_PATTERNS])];
+  const hooks = [];
+  for (const rel of await globFiles(cwd, list)) {
+    try {
+      const mod = await import(pathToFileURL(path.join(cwd, rel)).href);
+      const hook = normalizeHookModule(mod, rel);
+      if (hook) hooks.push({ ...hook, path: rel });
+    } catch {
+      /* modulo roto: se ignora */
+    }
+  }
+  return hooks;
+}

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

@@ -124,6 +124,8 @@ export {
   buildPathRulesBlock,
 } from './rules/index.js';
 export { parseScheduleSpec, parseCronFields, nextRun, nextRunFor } from './schedule/cron.js';
+export { loadHooks, normalizeHookModule, DEFAULT_HOOK_PATTERNS } from './hooks/index.js';
+export { loadPlugins, normalizePlugin, DEFAULT_PLUGIN_PATTERNS } from './plugins/index.js';
 export {
   searchMcpRegistry,
   getMcpRegistryServer,

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

@@ -0,0 +1,36 @@
+// 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) }`.
+
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { globFiles } from '../tools/glob.js';
+
+export const DEFAULT_PLUGIN_PATTERNS = ['.tamnora/plugins/*.mjs'];
+
+/** Normaliza el modulo de un plugin a `{ id, tools }` (o null). */
+export function normalizePlugin(mod, id = '') {
+  const value = mod?.default ?? mod;
+  if (!value || typeof value !== 'object') return null;
+  const tools = Array.isArray(value.tools) ? value.tools : [];
+  const valid = tools.filter((tool) => tool && typeof tool.name === 'string' && typeof tool.handler === 'function');
+  if (!valid.length) return null;
+  return { id: value.name || id, tools: valid };
+}
+
+/** Carga los plugins de `patterns` + `.tamnora/plugins/*.mjs`. */
+export async function loadPlugins(cwd, patterns = []) {
+  const list = [...new Set([...(patterns ?? []), ...DEFAULT_PLUGIN_PATTERNS])];
+  const plugins = [];
+  for (const rel of await globFiles(cwd, list)) {
+    try {
+      const mod = await import(pathToFileURL(path.join(cwd, rel)).href);
+      const plugin = normalizePlugin(mod, rel);
+      if (plugin) plugins.push({ ...plugin, path: rel });
+    } catch {
+      /* plugin roto: se ignora */
+    }
+  }
+  return plugins;
+}

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

@@ -2,9 +2,9 @@
 // Las que no tienen `paths` son estáticas (van siempre al system prompt); las
 // que sí, se inyectan en runtime cuando una tool toca un archivo que matchea.
 
-import { readFile, readdir, stat } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
 import path from 'node:path';
-import { globToRegExp } from '../tools/glob.js';
+import { globToRegExp, globFiles } from '../tools/glob.js';
 
 /** Parsea un archivo de reglas: frontmatter (name, paths/globs) + body. */
 export function parseRuleMarkdown(text, fallbackId = '') {
@@ -41,74 +41,20 @@ function normalizePaths(paths) {
   return [...new Set((paths ?? []).map((p) => String(p).replace(/\\/g, '/').replace(/^\.?\//, '').trim()).filter(Boolean))];
 }
 
-function hasGlob(pattern) {
-  return /[*?]/.test(pattern);
-}
-
-function fixedPrefix(pattern) {
-  if (!hasGlob(pattern)) return pattern;
-  const at = pattern.search(/[*?]/);
-  const slash = pattern.slice(0, at).lastIndexOf('/');
-  return slash >= 0 ? pattern.slice(0, slash) : '';
-}
-
 /** Carga y parsea los archivos de reglas que matchean `patterns` (rel a `root`). */
 export async function loadRules(root, patterns = []) {
-  const seen = new Set();
   const rules = [];
-  for (const pattern of patterns) {
-    const normalized = String(pattern).replace(/\\/g, '/');
-    const candidates = await matchFiles(root, normalized);
-    for (const rel of candidates) {
-      if (seen.has(rel)) continue;
-      seen.add(rel);
-      try {
-        const text = await readFile(path.join(root, rel), 'utf8');
-        const parsed = parseRuleMarkdown(text, rel);
-        if (!parsed.body) continue;
-        rules.push({ id: rel, name: parsed.name, paths: parsed.paths, body: parsed.body });
-      } catch {
-        /* ignore unreadable rule */
-      }
-    }
-  }
-  return rules.sort((a, b) => a.id.localeCompare(b.id, 'es'));
-}
-
-async function matchFiles(root, pattern) {
-  if (!hasGlob(pattern)) {
+  for (const rel of await globFiles(root, patterns)) {
     try {
-      return (await stat(path.join(root, pattern))).isFile() ? [pattern] : [];
+      const text = await readFile(path.join(root, rel), 'utf8');
+      const parsed = parseRuleMarkdown(text, rel);
+      if (!parsed.body) continue;
+      rules.push({ id: rel, name: parsed.name, paths: parsed.paths, body: parsed.body });
     } catch {
-      return [];
+      /* ignore unreadable rule */
     }
   }
-  const prefix = fixedPrefix(pattern);
-  const base = prefix ? path.join(root, prefix) : root;
-  const files = [];
-  const walk = async (dir, depth) => {
-    let entries;
-    try {
-      entries = await readdir(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (entry.name === '.git' || entry.name === 'node_modules') continue;
-      const full = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        if (depth < 6 && entry.name !== '.git' && entry.name !== 'node_modules') {
-          await walk(full, depth + 1);
-        }
-      } else if (entry.isFile()) {
-        const rel = path.relative(root, full).replace(/\\/g, '/');
-        files.push(rel);
-      }
-    }
-  };
-  await walk(base, 0);
-  const re = globToRegExp(pattern);
-  return files.filter((rel) => re.test(rel));
+  return rules.sort((a, b) => a.id.localeCompare(b.id, 'es'));
 }
 
 /** Reglas sin `paths` (aplican siempre). */

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

@@ -1,6 +1,5 @@
-import { readdir } from 'node:fs/promises';
+import { readdir, stat } from 'node:fs/promises';
 import path from 'node:path';
-
 export const DEFAULT_IGNORES = new Set([
   'node_modules',
   '.git',
@@ -65,3 +64,66 @@ export async function* walkFiles(root, { ignores = DEFAULT_IGNORES } = {}) {
     }
   }
 }
+
+function hasGlob(pattern) {
+  return /[*?]/.test(pattern);
+}
+
+function fixedPrefix(pattern) {
+  if (!hasGlob(pattern)) return pattern;
+  const at = pattern.search(/[*?]/);
+  const slash = pattern.slice(0, at).lastIndexOf('/');
+  return slash >= 0 ? pattern.slice(0, slash) : '';
+}
+
+async function matchPattern(root, pattern) {
+  if (!hasGlob(pattern)) {
+    try {
+      return (await stat(path.join(root, pattern))).isFile() ? [pattern] : [];
+    } catch {
+      return [];
+    }
+  }
+  const prefix = fixedPrefix(pattern);
+  const base = prefix ? path.join(root, prefix) : root;
+  const files = [];
+  const walk = async (dir, depth) => {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name === '.git' || entry.name === 'node_modules') continue;
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (depth < 6) await walk(full, depth + 1);
+      } else if (entry.isFile()) {
+        files.push(path.relative(root, full).replace(/\\/g, '/'));
+      }
+    }
+  };
+  await walk(base, 0);
+  const re = globToRegExp(pattern);
+  return files.filter((rel) => re.test(rel));
+}
+
+/**
+ * Resuelve una lista de patrones glob a archivos (relativos a `root`). A
+ * diferencia de `walkFiles`, entra en `.tamnora` (los patrones suelen apuntar
+ * ahi): solo saltea `.git` y `node_modules`.
+ */
+export async function globFiles(root, patterns = []) {
+  const seen = new Set();
+  const out = [];
+  for (const pattern of patterns) {
+    const rel = String(pattern).replace(/\\/g, '/');
+    for (const file of await matchPattern(root, rel)) {
+      if (seen.has(file)) continue;
+      seen.add(file);
+      out.push(file);
+    }
+  }
+  return out;
+}

package/harness/packages/core/test/hooks.test.js

@@ -0,0 +1,29 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { normalizeHookModule, loadHooks } from '../src/hooks/index.js';
+
+test('normalizeHookModule acepta objeto events, funcion y onEvent', () => {
+  const byEvents = normalizeHookModule({ default: { name: 'a', events: { 'run.end': () => {} } } }, 'x');
+  assert.equal(byEvents.id, 'a');
+  assert.deepEqual(Object.keys(byEvents.events), ['run.end']);
+  assert.ok(normalizeHookModule({ default: () => {} }, 'f').events['*']);
+  assert.ok(normalizeHookModule({ default: { onEvent: () => {} } }, 'o').events['*']);
+  assert.equal(normalizeHookModule({ default: {} }, 'n'), null);
+});
+
+test('loadHooks carga .tamnora/hooks/*.mjs e ignora lo roto', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-hooks-'));
+  await mkdir(path.join(cwd, '.tamnora', 'hooks'), { recursive: true });
+  await writeFile(
+    path.join(cwd, '.tamnora', 'hooks', 'demo.mjs'),
+    "export default { name: 'demo', events: { 'run.end': () => {} } };\n"
+  );
+  await writeFile(path.join(cwd, '.tamnora', 'hooks', 'roto.mjs'), 'this is not valid javascript {{{\n');
+  const hooks = await loadHooks(cwd, []);
+  assert.equal(hooks.length, 1);
+  assert.equal(hooks[0].id, 'demo');
+  assert.deepEqual(Object.keys(hooks[0].events), ['run.end']);
+});

package/harness/packages/core/test/plugins.test.js

@@ -0,0 +1,25 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { normalizePlugin, loadPlugins } from '../src/plugins/index.js';
+
+test('normalizePlugin filtra tools invalidas', () => {
+  const plugin = normalizePlugin({ default: { name: 'demo', tools: [{ name: 'x', handler: () => {} }, { name: 'bad' }] } }, 'z');
+  assert.equal(plugin.id, 'demo');
+  assert.equal(plugin.tools.length, 1);
+  assert.equal(normalizePlugin({ default: {} }, 'n'), null);
+});
+
+test('loadPlugins carga .tamnora/plugins/*.mjs', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-plugins-'));
+  await mkdir(path.join(cwd, '.tamnora', 'plugins'), { recursive: true });
+  await writeFile(
+    path.join(cwd, '.tamnora', 'plugins', 'demo.mjs'),
+    "export default { name: 'demo', tools: [{ name: 'saludar', handler: () => 'hi' }] };\n"
+  );
+  const plugins = await loadPlugins(cwd, []);
+  assert.equal(plugins.length, 1);
+  assert.equal(plugins[0].tools[0].name, 'saludar');
+});

package/harness/packages/server/public/app.js

@@ -3754,6 +3754,8 @@ const asesorExplainEl = $('#asesor-explain');
 const asesorAdviceEl = $('#asesor-advice');
 const asesorWordsEl = $('#asesor-words');
 const asesorNotesEl = $('#asesor-notes');
+const asesorProviderEl = $('#asesor-provider');
+const asesorModelEl = $('#asesor-model');
 const trProviderEl = $('#tr-provider');
 const trModelEl = $('#tr-model');
 
@@ -4734,6 +4736,8 @@ function aplicarAsesor(data) {
   if (asesorAdviceEl) asesorAdviceEl.checked = data.advice !== false;
   if (asesorWordsEl) asesorWordsEl.value = data.maxWords ?? 40;
   if (asesorNotesEl) asesorNotesEl.value = data.notes ?? '';
+  if (asesorProviderEl) asesorProviderEl.value = data.provider ?? '';
+  if (asesorModelEl) asesorModelEl.value = data.model ?? '';
   const estado = $('#asesor-status');
   if (estado) {
     estado.className = `summary${data.enabled ? ' ok' : ''}`;
@@ -4755,6 +4759,8 @@ function asesorBody() {
     advice: asesorAdviceEl?.checked !== false,
     maxWords: Number(asesorWordsEl?.value) || 40,
     notes: asesorNotesEl?.value ?? '',
+    provider: asesorProviderEl?.value ?? '',
+    model: asesorModelEl?.value ?? '',
   };
 }
 

package/harness/packages/server/public/index.html

@@ -37,7 +37,7 @@
   </head>
   <body>
     <header class="topbar">
-      <div class="brand"><span class="logo"><img src="/icons/logo.png" alt="Tamnora" /></span> <span id="topbar-section" class="topbar-section">chat</span> <span class="ver">v0.14.0</span></div>
+      <div class="brand"><span class="logo"><img src="/icons/logo.png" alt="Tamnora" /></span> <span id="topbar-section" class="topbar-section">chat</span> <span class="ver">v0.15.0</span></div>
       <nav class="tabs">
         <button class="tab active" data-tab="chat">chat</button>
         <button class="tab" data-tab="providers">proveedores</button>
@@ -737,8 +737,16 @@
           <p class="muted verify-line">
             Un asesor que observa lo que el agente hace, lo interpreta y solo habla cuando tiene
             algo que aportar: te alerta de un problema en el código, te explica un proceso o te da
-            un consejo. No lee la respuesta del agente. Usa el proveedor y modelo activos.
+            un consejo. No lee la respuesta del agente. Usa el proveedor y modelo activos, o unos propios.
           </p>
+          <div class="row">
+            <label class="field"><span>proveedor (opcional)</span>
+              <input id="asesor-provider" spellcheck="false" placeholder="por defecto: el activo" />
+            </label>
+            <label class="field grow"><span>modelo (opcional)</span>
+              <input id="asesor-model" spellcheck="false" placeholder="por defecto: el activo" />
+            </label>
+          </div>
           <label class="check" title="tener un asesor que interprete y comente el turno">
             <input id="asesor-enabled" type="checkbox" /> Habilitar el asesor
           </label>

package/harness/packages/server/src/lib/advisor.js

@@ -15,6 +15,8 @@ export const DEFAULT_ADVISOR = {
   advice: true,
   notes: '',
   maxWords: 40,
+  provider: '',
+  model: '',
 };
 
 const KINDS = new Set(['code', 'explain', 'advice']);
@@ -34,6 +36,8 @@ export function resolveAdvisor(app) {
     maxWords: Number.isFinite(maxWords)
       ? Math.min(Math.max(Math.round(maxWords), 10), 120)
       : DEFAULT_ADVISOR.maxWords,
+    provider: typeof saved.provider === 'string' ? saved.provider.trim().slice(0, 60) : '',
+    model: typeof saved.model === 'string' ? saved.model.trim().slice(0, 120) : '',
   };
 }
 

package/harness/packages/server/src/lib/agentRun.js

@@ -20,16 +20,18 @@ export function toolCallPayload(event) {
  * Combina tools locales + admin + subagentes en un toolset unificado.
  * `approve` es el callback de aprobacion de las tools de administraación.
  */
-export function combineToolset({ local, admin = null, tasks = null, exposeAdmin = false, approve = null }) {
+export function combineToolset({ local, admin = null, tasks = null, plugins = null, exposeAdmin = false, approve = null }) {
   const adminAllowed = (name) => Boolean(admin?.handles(name)) && (exposeAdmin || admin.readOnly?.has(name));
   const definitions = [
     ...local.definitions,
     ...(admin ? admin.definitions.filter((d) => adminAllowed(d.function.name)) : []),
     ...(tasks ? tasks.definitions : []),
+    ...(plugins ? plugins.definitions : []),
   ];
   const execute = (name, args, context = {}) => {
     if (tasks?.handles(name)) return tasks.execute(name, args);
     if (adminAllowed(name)) return admin.execute(name, args, { approve, ...context });
+    if (plugins?.handles(name)) return plugins.execute(name, args, { approve, ...context });
     return local.execute(name, args, context);
   };
   return { definitions, execute };

package/harness/packages/server/src/lib/channels/telegram.js

@@ -477,7 +477,13 @@ export function startTelegramChannel(
     });
     const exposeAdmin = !mode.tools;
     const admin = ctx.agentTools;
-    const { definitions, execute } = combineToolset({ local, admin, exposeAdmin, approve: onAsk });
+    const { definitions, execute } = combineToolset({
+      local,
+      admin,
+      plugins: exposeAdmin ? ctx.plugins : null,
+      exposeAdmin,
+      approve: onAsk,
+    });
     const { provider, config } = resolveProviderFor(ctx, providerId);
     const userMessage = buildUserMessage(input, images);
     const messages = await composeAgentMessages({ ctx, cwd, mode, history, userMessage });

package/harness/packages/server/src/lib/compact.js

@@ -52,8 +52,10 @@ export async function summarizeSession(ctx, session, instruction) {
   if (!messages.length) return { error: 'La sesión no tiene mensajes para resumir.', status: 400 };
   const resolved = providerFor(ctx, session);
   if (resolved.error) return resolved;
+  ctx.hooks?.dispatch({ type: 'session.compacting', sessionId: session.id, messages: messages.length });
   const summary = await summarize(ctx, session, messages, instruction);
   if (!summary) return { error: 'El modelo no devolvió un resumen.', status: 502 };
+  ctx.hooks?.dispatch({ type: 'session.compacted', sessionId: session.id, summary });
   return { summary };
 }
 
@@ -70,8 +72,10 @@ export async function maybeAutoCompact(ctx, session, history, { contextTokens }
   const live = liveHistory(history, session.meta?.summaryCursor ?? null);
   const plan = planCompaction(live, { contextTokens, threshold, keepLast });
   if (!plan) return null;
+  ctx.hooks?.dispatch({ type: 'session.compacting', sessionId: session.id, auto: true, messages: plan.toSummarize.length });
   const summary = await summarize(ctx, session, plan.toSummarize, COMPACT_INSTRUCTION, session.meta?.summary);
   if (!summary) return null;
   ctx.store.touchSession(session.id, { meta: { summary, summaryCursor: plan.cursor } });
+  ctx.hooks?.dispatch({ type: 'session.compacted', sessionId: session.id, auto: true, summary });
   return { summary, cursor: plan.cursor, summarized: plan.toSummarize.length };
 }

package/harness/packages/server/src/lib/hooks.js

@@ -0,0 +1,45 @@
+// Runner de hooks: carga los modulos (`core/src/hooks`) y despacha eventos a
+// sus handlers de forma aislada (un hook que tira no rompe el run) y con los
+// datos redactados. Es opt-in: sin archivos de hooks, no se ejecuta codigo.
+
+import { loadHooks, redactDeep } from './core.js';
+
+/**
+ * Crea el runner. `dispatch(event)` llama a los handlers suscritos a
+ * `event.type` (y a los wildcard `*`); no devuelve valor (observadores).
+ */
+export async function createHookRunner(ctx, patterns = []) {
+  let hooks = [];
+  try {
+    hooks = await loadHooks(ctx.cwd, patterns);
+  } catch {
+    hooks = [];
+  }
+  const handlers = new Map();
+  for (const hook of hooks) {
+    for (const [event, fn] of Object.entries(hook.events)) {
+      if (typeof fn !== 'function') continue;
+      const list = handlers.get(event) ?? [];
+      list.push(fn);
+      handlers.set(event, list);
+    }
+  }
+
+  function dispatch(event) {
+    const list = [...(handlers.get(event.type) ?? []), ...(handlers.get('*') ?? [])];
+    if (!list.length) return;
+    const safe = redactDeep(event);
+    for (const fn of list) {
+      Promise.resolve()
+        .then(() => fn(safe, ctx))
+        .catch(() => {
+          // un hook caido no debe frenar el run
+        });
+    }
+  }
+
+  const view = () =>
+    hooks.map((hook) => ({ id: hook.id, path: hook.path, events: Object.keys(hook.events).filter((e) => e !== '*') }));
+
+  return { dispatch, count: hooks.length, list: view };
+}

package/harness/packages/server/src/lib/plugins.js

@@ -0,0 +1,76 @@
+// Plugins: agregan herramientas propias al agente (`.tamnora/plugins/*.mjs` o
+// las rutas de `config.plugins`). Corren codigo del usuario, asi que pasan por
+// permisos (default `ask`).
+
+import { loadPlugins } from './core.js';
+
+function normalizeName(value) {
+  return String(value ?? '')
+    .replace(/[^a-z0-9_-]+/gi, '_')
+    .replace(/^_+|_+$/g, '')
+    .slice(0, 64);
+}
+
+/** Crea el toolset de plugins. `execute(name, args, { approve })`. */
+export async function createPlugins(ctx, patterns = []) {
+  let plugins = [];
+  try {
+    plugins = await loadPlugins(ctx.cwd, patterns);
+  } catch {
+    plugins = [];
+  }
+
+  const tools = [];
+  const used = new Set();
+  for (const plugin of plugins) {
+    for (const tool of plugin.tools) {
+      const name = `plugin__${normalizeName(plugin.id)}__${normalizeName(tool.name)}`;
+      if (!name || used.has(name)) continue;
+      used.add(name);
+      tools.push({
+        name,
+        source: tool.name,
+        plugin: plugin.id,
+        description: String(tool.description || tool.name),
+        parameters: tool.parameters && typeof tool.parameters === 'object' ? tool.parameters : {},
+        required: Array.isArray(tool.required) ? tool.required : [],
+        handler: tool.handler,
+      });
+    }
+  }
+
+  const byName = new Map(tools.map((tool) => [tool.name, tool]));
+  const definitions = tools.map((tool) => ({
+    type: 'function',
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: { type: 'object', properties: tool.parameters, required: tool.required },
+    },
+  }));
+
+  async function execute(name, args = {}, { approve } = {}) {
+    const tool = byName.get(name);
+    if (!tool) return `Herramienta desconocida: ${name}`;
+    const decision = (ctx.config.permissions ?? {})[tool.name] ?? 'ask';
+    if (decision === 'deny') return `Permiso denegado para "${name}".`;
+    if (decision === 'ask') {
+      const ok = approve ? await approve(name, args) : false;
+      if (!ok) return `Permiso denegado para "${name}".`;
+    }
+    try {
+      const out = await tool.handler(args, ctx);
+      return typeof out === 'string' ? out : JSON.stringify(out ?? null, null, 2);
+    } catch (error) {
+      return `Error en ${name}: ${error?.message ?? error}`;
+    }
+  }
+
+  return {
+    definitions,
+    handles: (name) => byName.has(name),
+    execute,
+    count: tools.length,
+    list: () => tools.map(({ name, source, plugin, description }) => ({ name, source, plugin, description })),
+  };
+}

package/harness/packages/server/src/lib/scheduler.js

@@ -68,7 +68,14 @@ async function runAgentSchedule(ctx, schedule) {
     exclude: admin.definitions.map((d) => d.function.name),
     emit,
   });
-  const { definitions, execute } = combineToolset({ local, admin, tasks, exposeAdmin, approve: async () => true });
+  const { definitions, execute } = combineToolset({
+    local,
+    admin,
+    tasks,
+    plugins: exposeAdmin ? ctx.plugins : null,
+    exposeAdmin,
+    approve: async () => true,
+  });
   const { provider, config } = resolveProviderFor(ctx, providerId);
 
   try {

package/harness/packages/server/src/routes/advisor.js

@@ -20,6 +20,8 @@ export function registerAdvisor(route, ctx) {
     if ('explain' in body) next.explain = body.explain !== false;
     if ('advice' in body) next.advice = body.advice !== false;
     if ('notes' in body) next.notes = String(body.notes ?? '').slice(0, 2000);
+    if ('provider' in body) next.provider = String(body.provider ?? '').trim().slice(0, 60);
+    if ('model' in body) next.model = String(body.model ?? '').trim().slice(0, 120);
     if ('maxWords' in body) {
       const value = Number(body.maxWords);
       next.maxWords = Number.isFinite(value)
@@ -34,8 +36,8 @@ export function registerAdvisor(route, ctx) {
 
   route('POST', '/api/advisor/test', async ({ res }) => {
     const options = resolveAdvisor(ctx.app);
-    const providerId = ctx.effectiveProviderId();
-    const model = ctx.effectiveModel();
+    const providerId = options.provider || ctx.effectiveProviderId();
+    const model = options.model || ctx.effectiveModel();
     if (!model) return sendError(res, 400, 'Elegí un proveedor y un modelo primero.');
     const { provider, config } = ctx.resolveProvider({
       ...ctx.providerSettings(providerId),

package/harness/packages/server/src/routes/chat.js

@@ -221,11 +221,18 @@ export function registerChat(route, ctx) {
       permissions: ctx.config.permissions,
       mcp,
       signal: ctx.runs.signal(sessionId),
-      exclude: admin.definitions.map((d) => d.function.name),
+      exclude: [...admin.definitions.map((d) => d.function.name), ...(ctx.plugins?.list?.().map((t) => t.name) ?? [])],
       emit: emitAgent,
     });
     const approve = autoApprove ? async () => true : (name, args) => onAsk(name, args);
-    const { definitions, execute } = combineToolset({ local, admin, tasks, exposeAdmin, approve });
+    const { definitions, execute } = combineToolset({
+      local,
+      admin,
+      tasks,
+      plugins: exposeAdmin ? ctx.plugins : null,
+      exposeAdmin,
+      approve,
+    });
 
     const { provider, config } = resolveProviderFor(ctx, providerId, {
       baseUrl: body.baseUrl || ctx.providerSettings(providerId).baseUrl,
@@ -261,6 +268,7 @@ export function registerChat(route, ctx) {
     const onLifecycle = combineLifecycle([
       createRulesInjector({ cwd: sessionCwd, patterns: ctx.config.rules ?? [] }),
       createCheckpointer(ctx, { sessionId, cwd: sessionCwd, turnId: userMessageId }),
+      ctx.hooks ? (event) => ctx.hooks.dispatch(event) : null,
     ]);
 
     (async () => {
@@ -356,10 +364,20 @@ export function registerChat(route, ctx) {
           advisorOptions.enabled &&
           advisorShouldRun({ toolCalls, answer: result.content })
         ) {
+          // El asesor puede tener proveedor/modelo propios; si no, usa los activos.
+          let advisorProvider = provider;
+          let advisorConfig = config;
+          let advisorModel = model;
+          if (advisorOptions.provider || advisorOptions.model) {
+            const resolved = resolveProviderFor(ctx, advisorOptions.provider || providerId);
+            advisorProvider = resolved.provider;
+            advisorConfig = resolved.config;
+            advisorModel = advisorOptions.model || model;
+          }
           const advice = await consultAdvisor({
-            provider,
-            config,
-            model,
+            provider: advisorProvider,
+            config: advisorConfig,
+            model: advisorModel,
             signal: ctx.runs.signal(sessionId),
             userInput: input,
             answer: result.content,
@@ -374,6 +392,7 @@ export function registerChat(route, ctx) {
               mode: advice.kind,
             });
             ctx.runs.emit(sessionId, 'advice', { text: advice.text, kind: advice.kind, say: advice.text });
+            ctx.hooks?.dispatch({ type: 'advice', sessionId, text: advice.text, kind: advice.kind });
           }
         }
       } catch (error) {

package/harness/packages/server/src/server.js

@@ -53,6 +53,8 @@ import { registerPresence } from './routes/presence.js';
 import { registerEval } from './routes/eval.js';
 import { registerSchedules } from './routes/schedules.js';
 import { createScheduler } from './lib/scheduler.js';
+import { createHookRunner } from './lib/hooks.js';
+import { createPlugins } from './lib/plugins.js';
 
 const VERSION = readPackageVersion();
 
@@ -217,6 +219,12 @@ export async function createTamnoraServer({
   ctx.systemPrompt = (await ctx.systemPromptFor(cwd)) || DEFAULT_SYSTEM_PROMPT;
   ctx.agentTools = createAgentTools(ctx);
 
+  // Hooks locales (opt-in: solo si hay archivos). Observan el ciclo de vida.
+  ctx.hooks = await createHookRunner(ctx, config.hooks ?? []);
+
+  // Plugins locales: tools propias del usuario (`.tamnora/plugins/*.mjs`).
+  ctx.plugins = await createPlugins(ctx, config.plugins ?? []);
+
   // Canales de mensajeria (Telegram via long polling) si hay token.
   const channels = createChannelsManager(ctx, {
     enabled: telegram,
@@ -270,6 +278,14 @@ export async function createTamnoraServer({
   registerEval(route, ctx);
   registerSchedules(route, ctx);
 
+  route('GET', '/api/hooks', ({ res }) => {
+    sendJson(res, 200, { hooks: ctx.hooks?.list?.() ?? [] });
+  });
+
+  route('GET', '/api/plugins', ({ res }) => {
+    sendJson(res, 200, { plugins: ctx.plugins?.list?.() ?? [] });
+  });
+
   function matchRoute(method, pathname) {
     const parts = pathname.split('/').filter(Boolean);
     for (const r of routes) {

package/harness/packages/server/test/server.test.js

@@ -1356,6 +1356,72 @@ test('rewind restores files and truncates the turn', async () => {
   }
 });
 
+test('hooks observe tool events and plugins add custom tools', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-hooks-plugins-'));
+  await mkdir(path.join(cwd, '.tamnora', 'hooks'), { recursive: true });
+  await mkdir(path.join(cwd, '.tamnora', 'plugins'), { recursive: true });
+  await writeFile(
+    path.join(cwd, '.tamnora', 'hooks', 'audit.mjs'),
+    "import { appendFileSync } from 'node:fs';\nimport path from 'node:path';\n" +
+      "export default { name: 'audit', events: { 'tool.after': (event, ctx) => { appendFileSync(path.join(ctx.cwd, 'hook.log'), `${event.type}:${event.name}\\n`); } } };\n"
+  );
+  await writeFile(
+    path.join(cwd, '.tamnora', 'plugins', 'demo.mjs'),
+    "export default { name: 'demo', tools: [{ name: 'saludar', description: 'saluda', parameters: { quien: { type: 'string' } }, handler: (args) => `Hola ${args.quien}` }] };\n"
+  );
+  await writeFile(path.join(cwd, 'tamnora.json'), JSON.stringify({ permissions: { plugin__demo__saludar: 'allow' } }));
+
+  let captured = null;
+  const provider = {
+    id: 'hp',
+    async streamChat(_config, { messages }) {
+      const toolMsg = messages.find((m) => m.role === 'tool' && String(m.name).startsWith('plugin__'));
+      if (toolMsg) {
+        captured = toolMsg.content;
+        return { content: 'ok', reasoning: '', toolCalls: [] };
+      }
+      return {
+        content: '',
+        reasoning: '',
+        toolCalls: [
+          {
+            id: 't1',
+            type: 'function',
+            function: { name: 'plugin__demo__saludar', arguments: JSON.stringify({ quien: 'mundo' }) },
+          },
+        ],
+      };
+    },
+  };
+  const { instance, base } = await startServer({ cwd, resolveProvider: () => ({ provider, config: {} }) });
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    const hooks = await (await fetch(`${base}/api/hooks`)).json();
+    assert.ok(hooks.hooks.some((h) => h.id === 'audit'));
+
+    const plugins = await (await fetch(`${base}/api/plugins`)).json();
+    assert.ok(plugins.plugins.some((p) => p.name === 'plugin__demo__saludar'));
+
+    const created = await (
+      await fetch(`${base}/api/sessions`, { method: 'POST', headers: json, body: JSON.stringify({ title: 't', model: 'm', cwd }) })
+    ).json();
+    await (
+      await fetch(`${base}/api/chat`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ sessionId: created.session.id, model: 'm', input: 'saludá' }),
+      })
+    ).text();
+    assert.equal(captured, 'Hola mundo');
+
+    await new Promise((resolve) => setTimeout(resolve, 150));
+    const log = await readFile(path.join(cwd, 'hook.log'), 'utf8').catch(() => '');
+    assert.match(log, /tool\.after:plugin__demo__saludar/);
+  } finally {
+    await instance.close();
+  }
+});
+
 test('skills: modo eager inyecta el body en el system prompt', async () => {
   let captured = '';
   const captureProvider = {

package/harness/tamnora.example.json

@@ -11,6 +11,8 @@
   "compact": { "enabled": true, "threshold": 0.75, "keepLast": 8 },
   "rules": [".tamnora/rules/*.md"],
   "memory": { "enabled": true },
+  "hooks": [],
+  "plugins": [],
   "tools": [],
   "permissions": {},
   "mcp": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danieltmn/tamnora",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Harness local para IAs: agente CLI-first con TUI, consola web y evaluacion. Node puro, sin dependencias.",
   "type": "module",
   "packageManager": "pnpm@11.25.0",