@danieltmn/tamnora 0.13.1 → 0.15.0

package/CHANGELOG.md

@@ -5,6 +5,44 @@ 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
+
+- **Fase 3 del roadmap del server (automatización y seguridad)**:
+  - **Tareas programadas**: `every N m|h`, `hourly`, `daily HH:MM` y un subconjunto
+    de cron. El scheduler corre un tick cada 30 s y dispara tareas `agent` (turno
+    headless que reusa el historial y avisa por los canales) o `shell` (con la
+    allowlist de procesos). CRUD en `/api/schedules` y pestaña **Tareas**.
+  - **Deshacer (checkpoints/rewind)**: se guarda la versión previa de los archivos
+    que `write`/`edit` tocan y `POST /api/sessions/:id/rewind` restaura los
+    archivos y borra el turno del historial. Acción **deshacer cambios** en el menú
+    de cada mensaje del asistente.
+
+### Cambios
+
+- Consola: el botón de tema muestra el icono del tema al que se va a cambiar
+  (en claro, luna; en oscuro, sol). Igual en la landing.
+- Consola: el fondo del chat pasa a un color sólido; la imagen queda solo en la
+  landing.
+- Consola: los botones de los paneles (p. ej. cerrar/refrescar) ya no se recortan
+  al angostar: las pestañas se comprimen y hacen scroll.
+
 ## [0.13.1] - 2026-10-10
 
 ### Arreglado

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

@@ -123,6 +123,9 @@ export {
   buildStaticRulesBlock,
   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/schedule/cron.js

@@ -0,0 +1,124 @@
+// Especificaciones de programación (puro, sin dependencias): `every N m|h`,
+// `hourly`, `daily HH:MM`, `HH:MM` y un subconjunto de cron (5 campos:
+// minuto hora dia-mes mes dia-semana) con `*`, listas, rangos y pasos.
+
+const MINUTE = 60_000;
+
+function parseField(text, min, max) {
+  const out = new Set();
+  for (const part of String(text).split(',')) {
+    const token = part.trim();
+    if (!token) return null;
+    const [rangePart, stepPart] = token.split('/');
+    const step = stepPart === undefined ? 1 : Number(stepPart);
+    if (!Number.isInteger(step) || step <= 0) return null;
+    let start;
+    let end;
+    if (rangePart === '*') {
+      start = min;
+      end = max;
+    } else {
+      const range = rangePart.split('-');
+      start = Number(range[0]);
+      end = range.length > 1 ? Number(range[1]) : start;
+      if (!Number.isInteger(start) || !Number.isInteger(end)) return null;
+    }
+    if (start < min || end > max || start > end) return null;
+    for (let v = start; v <= end; v += step) out.add(v);
+  }
+  return out;
+}
+
+/** Parsea los 5 campos de cron. Devuelve null si es inválido. */
+export function parseCronFields(parts) {
+  const [minute, hour, dom, month, dow] = parts;
+  const fields = {
+    minute: parseField(minute, 0, 59),
+    hour: parseField(hour, 0, 23),
+    dom: parseField(dom, 1, 31),
+    month: parseField(month, 1, 12),
+    dow: parseField(dow, 0, 6),
+  };
+  if (Object.values(fields).some((set) => !set)) return null;
+  fields.domStar = dom.trim() === '*';
+  fields.dowStar = dow.trim() === '*';
+  return fields;
+}
+
+/**
+ * Normaliza una especificación a `{ type, ... }` o null:
+ *  - `{ type: 'every', minutes }`
+ *  - `{ type: 'daily', hour, minute }`
+ *  - `{ type: 'cron', fields }`
+ */
+export function parseScheduleSpec(spec) {
+  const text = String(spec ?? '').trim().toLowerCase();
+  if (!text) return null;
+
+  const every = text.match(/^every\s+(\d+)\s*(m|min|mins|minute|minutes|h|hr|hour|hours)$/);
+  if (every) {
+    const n = Number(every[1]);
+    if (n <= 0) return null;
+    return { type: 'every', minutes: every[2].startsWith('h') ? n * 60 : n, spec: text };
+  }
+  if (/^(every\s+hour|hourly)$/.test(text)) return { type: 'every', minutes: 60, spec: text };
+
+  const time = text.match(/^(?:daily\s+)?(\d{1,2}):(\d{2})$/);
+  if (time) {
+    const hour = Number(time[1]);
+    const minute = Number(time[2]);
+    if (hour > 23 || minute > 59) return null;
+    return { type: 'daily', hour, minute, spec: text };
+  }
+
+  const parts = text.split(/\s+/);
+  if (parts.length === 5) {
+    const fields = parseCronFields(parts);
+    if (!fields) return null;
+    return { type: 'cron', fields, spec: text };
+  }
+  return null;
+}
+
+function cronMatches(fields, date) {
+  if (!fields.minute.has(date.getMinutes())) return false;
+  if (!fields.hour.has(date.getHours())) return false;
+  if (!fields.month.has(date.getMonth() + 1)) return false;
+  const domMatch = fields.dom.has(date.getDate());
+  const dowMatch = fields.dow.has(date.getDay());
+  if (fields.domStar && fields.dowStar) return true;
+  if (fields.domStar) return dowMatch;
+  if (fields.dowStar) return domMatch;
+  return domMatch || dowMatch;
+}
+
+/** Próximo instante (ms) en que corre, estrictamente después de `from`. */
+export function nextRun(parsed, from = Date.now()) {
+  if (!parsed) return null;
+  if (parsed.type === 'every') {
+    const ms = parsed.minutes * MINUTE;
+    return Math.floor(from / ms) * ms + ms;
+  }
+  if (parsed.type === 'daily') {
+    const next = new Date(from);
+    next.setSeconds(0, 0);
+    next.setHours(parsed.hour, parsed.minute, 0, 0);
+    if (next.getTime() <= from) next.setDate(next.getDate() + 1);
+    return next.getTime();
+  }
+  const limit = from + 366 * 24 * 60 * MINUTE;
+  const cursor = new Date(from);
+  cursor.setSeconds(0, 0);
+  cursor.setMinutes(cursor.getMinutes() + 1);
+  while (cursor.getTime() <= limit) {
+    if (cronMatches(parsed.fields, cursor)) return cursor.getTime();
+    cursor.setMinutes(cursor.getMinutes() + 1);
+  }
+  return null;
+}
+
+/** `parse + nextRun` en un paso. */
+export function nextRunFor(spec, from = Date.now()) {
+  const parsed = parseScheduleSpec(spec);
+  return parsed ? nextRun(parsed, from) : null;
+}

package/harness/packages/core/src/storage/sqlite.js

@@ -115,6 +115,21 @@ CREATE TABLE IF NOT EXISTS settings (
   key TEXT PRIMARY KEY,
   value TEXT
 );
+
+CREATE TABLE IF NOT EXISTS schedules (
+  id TEXT PRIMARY KEY,
+  name TEXT,
+  type TEXT,
+  spec TEXT,
+  payload TEXT,
+  cwd TEXT,
+  enabled INTEGER,
+  last_run INTEGER,
+  last_status TEXT,
+  next_run INTEGER,
+  created_at INTEGER,
+  updated_at INTEGER
+);
 `;
 
 /** Open (creating if needed) a SQLite database with the harness schema. */
@@ -533,8 +548,71 @@ export class Store {
     this.db.prepare(`DELETE FROM providers WHERE id = ?`).run(id);
   }
 
-  // --- Settings (key/value) ----------------------------------------------
+  // --- Schedules (tareas programadas) ------------------------------------
+
+  listSchedules() {
+    return this.db
+      .prepare(`SELECT * FROM schedules ORDER BY created_at ASC`)
+      .all()
+      .map(toSchedule);
+  }
+
+  getSchedule(id) {
+    const row = this.db.prepare(`SELECT * FROM schedules WHERE id = ?`).get(id);
+    return row ? toSchedule(row) : null;
+  }
 
+  saveSchedule(schedule) {
+    const ts = now();
+    const existing = this.getSchedule(schedule.id);
+    this.db
+      .prepare(
+        `INSERT INTO schedules (id, name, type, spec, payload, cwd, enabled, last_run, last_status, next_run, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           name = excluded.name, type = excluded.type, spec = excluded.spec, payload = excluded.payload,
+           cwd = excluded.cwd, enabled = excluded.enabled, next_run = excluded.next_run, updated_at = excluded.updated_at`
+      )
+      .run(
+        schedule.id,
+        schedule.name ?? schedule.id,
+        schedule.type ?? 'agent',
+        schedule.spec ?? '',
+        json(schedule.payload ?? {}),
+        schedule.cwd ?? null,
+        schedule.enabled === false ? 0 : 1,
+        schedule.lastRun ?? existing?.lastRun ?? null,
+        schedule.lastStatus ?? existing?.lastStatus ?? null,
+        schedule.nextRun ?? null,
+        existing?.createdAt ?? ts,
+        ts
+      );
+    return this.getSchedule(schedule.id);
+  }
+
+  deleteSchedule(id) {
+    this.db.prepare(`DELETE FROM schedules WHERE id = ?`).run(id);
+  }
+
+  setScheduleEnabled(id, enabled) {
+    this.db.prepare(`UPDATE schedules SET enabled = ?, updated_at = ? WHERE id = ?`).run(enabled ? 1 : 0, now(), id);
+  }
+
+  markScheduleRun(id, { status, nextRun } = {}) {
+    this.db
+      .prepare(`UPDATE schedules SET last_run = ?, last_status = ?, next_run = ?, updated_at = ? WHERE id = ?`)
+      .run(now(), status ?? null, nextRun ?? null, now(), id);
+  }
+
+  /** Tareas habilitadas cuyo `next_run` ya venció. */
+  dueSchedules(at = Date.now()) {
+    return this.db
+      .prepare(`SELECT * FROM schedules WHERE enabled = 1 AND next_run IS NOT NULL AND next_run <= ? ORDER BY next_run ASC`)
+      .all(at)
+      .map(toSchedule);
+  }
+
+  // --- Settings (key/value) ----------------------------------------------
   getSetting(key, fallback = null) {
     const row = this.db.prepare(`SELECT value FROM settings WHERE key = ?`).get(key);
     return row ? parseJson(row.value) : fallback;
@@ -574,6 +652,23 @@ function toAgent(row) {
   };
 }
 
+function toSchedule(row) {
+  return {
+    id: row.id,
+    name: row.name ?? row.id,
+    type: row.type ?? 'agent',
+    spec: row.spec ?? '',
+    payload: parseJson(row.payload) ?? {},
+    cwd: row.cwd ?? null,
+    enabled: row.enabled === 0 ? false : true,
+    lastRun: row.last_run ?? null,
+    lastStatus: row.last_status ?? null,
+    nextRun: row.next_run ?? null,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
 function toProvider(row) {
   return {
     id: row.id,

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/cron.test.js

@@ -0,0 +1,46 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { parseScheduleSpec, nextRun, nextRunFor } from '../src/schedule/cron.js';
+
+test('parseScheduleSpec accepts every / hourly / daily / time', () => {
+  assert.deepEqual(parseScheduleSpec('every 15 m'), { type: 'every', minutes: 15, spec: 'every 15 m' });
+  assert.equal(parseScheduleSpec('every 2 h').minutes, 120);
+  assert.equal(parseScheduleSpec('hourly').minutes, 60);
+  assert.deepEqual(parseScheduleSpec('daily 09:30'), { type: 'daily', hour: 9, minute: 30, spec: 'daily 09:30' });
+  assert.equal(parseScheduleSpec('08:05').type, 'daily');
+  assert.equal(parseScheduleSpec('bogus'), null);
+  assert.equal(parseScheduleSpec('every 0 m'), null);
+});
+
+test('nextRun for every aligns to the interval', () => {
+  const from = new Date('2026-01-01T10:07:00').getTime();
+  const next = new Date(nextRun(parseScheduleSpec('every 15 m'), from));
+  assert.equal(next.getHours(), 10);
+  assert.equal(next.getMinutes(), 15);
+});
+
+test('nextRun for daily picks today or tomorrow', () => {
+  const spec = parseScheduleSpec('daily 09:00');
+  const before = new Date('2026-01-01T08:00:00').getTime();
+  assert.equal(new Date(nextRun(spec, before)).getDate(), 1);
+  const after = new Date('2026-01-01T10:00:00').getTime();
+  assert.equal(new Date(nextRun(spec, after)).getDate(), 2);
+});
+
+test('nextRun for a cron subset', () => {
+  const from = new Date('2026-01-01T10:00:00').getTime();
+  const next = new Date(nextRun(parseScheduleSpec('30 14 * * *'), from));
+  assert.equal(next.getHours(), 14);
+  assert.equal(next.getMinutes(), 30);
+});
+
+test('nextRun for weekday cron skips to the right day', () => {
+  const from = new Date('2026-01-01T00:00:00').getTime(); // Thursday
+  const next = new Date(nextRun(parseScheduleSpec('0 6 * * 1'), from)); // Monday 06:00
+  assert.equal(next.getDay(), 1);
+  assert.equal(next.getHours(), 6);
+});
+
+test('nextRunFor returns null for invalid spec', () => {
+  assert.equal(nextRunFor('nope'), null);
+});

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');
+});