@danieltmn/tamnora 0.12.0 → 0.13.1

package/CHANGELOG.md

@@ -5,6 +5,29 @@ 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.13.1] - 2026-10-10
+
+### Arreglado
+
+- El test de permisos ya no es flaky: verifica que el `askId` resuelto no
+  reaparezca (antes asumía que no quedaba ninguno pendiente, lo que fallaba por
+  carrera cuando el agente ya pedía el siguiente permiso).
+
+## [0.13.0] - 2026-10-10
+
+### Agregado
+
+- **Fase 2 del roadmap del server (memoria y reglas)**:
+  - **Memoria durable por proyecto** (`.tamnora/memory/`): `MEMORY.md` como índice
+    y un archivo por tema. La maneja el agente con la tool `memory`
+    (`read | write | search | list`; `write` = `ask`) y se inyecta un resumen en el
+    system prompt de cada corrida. Nueva pestaña **Memoria** en la consola y
+    `GET/PUT/DELETE /api/memory`.
+  - **Reglas por path** (`rules: ['.tamnora/rules/*.md']`): archivos `.md` con
+    frontmatter `paths:` (globs). Las estáticas entran al system prompt; las
+    contextuales se inyectan en runtime cuando una tool toca un archivo que
+    matchea, de forma efímera (no ensucian el historial).
+
 ## [0.12.0] - 2026-10-10
 
 ### Agregado

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

@@ -68,7 +68,17 @@ export async function runAgent({
   onLifecycle,
 }) {
   const working = [...messages];
-  const emitLifecycle = (type, payload) => onLifecycle?.({ type, ...payload });
+  // Mensajes efimeros (p. ej. reglas por path inyectadas en runtime): entran al
+  // contexto de las proximas rondas pero NO se persisten en el historial.
+  const transient = [];
+  const emitLifecycle = (type, payload) => {
+    if (!onLifecycle) return undefined;
+    try {
+      return onLifecycle({ type, ...payload });
+    } catch {
+      return undefined;
+    }
+  };
   emitLifecycle('run.start', { model });
   let usageTotal = null;
   const startedAt = Date.now();
@@ -110,9 +120,9 @@ export async function runAgent({
 
     // Presupuesto de contexto: el recorte va sobre una copia; `working` sigue
     // completo para persistir el historial con indices estables.
-    let contextMessages = working;
+    let contextMessages = transient.length ? [...working, ...transient] : working;
     if (contextTokens > 0) {
-      const trimmedResult = trimContext(working, { maxTokens: contextTokens });
+      const trimmedResult = trimContext(contextMessages, { maxTokens: contextTokens });
       contextMessages = trimmedResult.messages;
       if (trimmedResult.trimmed || trimmedResult.dropped) {
         onEvent?.({
@@ -216,13 +226,12 @@ export async function runAgent({
         output = NO_PROGRESS_MESSAGE;
       } else {
         newCalls++;
-        emitLifecycle('tool.before', { id: call.id, name, args });
+        await emitLifecycle('tool.before', { id: call.id, name, args });
         try {
           output = await execute(name, args, toolContext);
         } catch (err) {
           output = `Error ejecutando ${name}: ${err?.message ?? err}`;
         }
-        emitLifecycle('tool.after', { id: call.id, name, args, result: output });
       }
 
       const normalized = normalizeToolOutput(output);
@@ -239,6 +248,15 @@ export async function runAgent({
         name,
         content: normalized.content,
       });
+
+      if (!(repeatLimit > 0 && seen > repeatLimit)) {
+        const after = await emitLifecycle('tool.after', { id: call.id, name, args, result: output });
+        const inject = after && typeof after === 'object' ? after.inject : undefined;
+        if (typeof inject === 'string' && inject.trim()) {
+          transient.push({ role: 'system', content: inject });
+          if (transient.length > 6) transient.shift();
+        }
+      }
     }
 
     noProgressStreak = newCalls === 0 ? noProgressStreak + 1 : 0;

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

@@ -14,6 +14,8 @@ export const DEFAULT_CONFIG = {
   promptCaching: false,
   skills: { mode: 'lazy' },
   compact: { enabled: true, threshold: 0.75, keepLast: 8 },
+  rules: ['.tamnora/rules/*.md'],
+  memory: { enabled: true },
   tools: [],
   permissions: {},
   mcp: [],

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

@@ -97,6 +97,32 @@ export {
   buildSkillsIndex,
 } from './skills/index.js';
 export { parseSkillRef, fetchSkillFromGithub } from './skills/remote.js';
+export {
+  MEMORY_DIR,
+  MEMORY_INDEX_NAME,
+  memoryRoot,
+  memoryIndexPath,
+  memorySlug,
+  isMemoryTopic,
+  readMemoryIndex,
+  listMemoryTopics,
+  readMemoryTopic,
+  writeMemory,
+  writeIndex as writeMemoryIndex,
+  deleteMemory,
+  searchMemory,
+  memoryPrompt,
+} from './memory/index.js';
+export {
+  parseRuleMarkdown,
+  loadRules,
+  staticRules,
+  pathRules,
+  ruleMatchesPath,
+  rulesForPath,
+  buildStaticRulesBlock,
+  buildPathRulesBlock,
+} from './rules/index.js';
 export {
   searchMcpRegistry,
   getMcpRegistryServer,

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

@@ -0,0 +1,220 @@
+// Memoria durable por proyecto: `<cwd>/.tamnora/memory/` con un `MEMORY.md`
+// (índice) y un archivo por tema. La escribe el agente (tool `memory`) y el
+// usuario la edita desde la consola. Es pura: solo toca el filesystem del cwd.
+
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+export const MEMORY_DIR = '.tamnora/memory';
+export const MEMORY_INDEX_NAME = 'MEMORY.md';
+export const MAX_INDEX_BYTES = 25 * 1024;
+export const MAX_INDEX_LINES = 200;
+export const MAX_TOPIC_BYTES = 64 * 1024;
+
+/** Carpeta de memoria del proyecto. */
+export function memoryRoot(cwd = process.cwd()) {
+  return path.join(cwd, '.tamnora', 'memory');
+}
+
+export function memoryIndexPath(cwd) {
+  return path.join(memoryRoot(cwd), MEMORY_INDEX_NAME);
+}
+
+/** Slug de tema (a-z, 0-9, -). */
+export function memorySlug(value) {
+  return String(value ?? '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 60);
+}
+
+/** Un nombre de archivo de tema válido (`.md`, no el índice). */
+export function isMemoryTopic(name) {
+  const slug = String(name ?? '');
+  if (!/^[a-z0-9][a-z0-9_-]*\.md$/i.test(slug)) return false;
+  return slug.toLowerCase() !== MEMORY_INDEX_NAME.toLowerCase();
+}
+
+function clampIndex(text) {
+  const lines = String(text ?? '').split(/\r?\n/).slice(0, MAX_INDEX_LINES);
+  let out = lines.join('\n');
+  if (Buffer.byteLength(out, 'utf8') > MAX_INDEX_BYTES) out = out.slice(0, MAX_INDEX_BYTES);
+  return out;
+}
+
+function firstLine(text) {
+  return (
+    String(text ?? '')
+      .split(/\r?\n/)
+      .map((l) => l.replace(/^#+\s*/, '').trim())
+      .find((l) => l) ?? ''
+  );
+}
+
+function headingOf(text) {
+  const line = String(text ?? '')
+    .split(/\r?\n/)
+    .find((l) => /^#\s/.test(l));
+  return line ? line.replace(/^#+\s*/, '').trim() : '';
+}
+
+/** Índice `MEMORY.md` (acotado). '' si no existe. */
+export function readMemoryIndex(cwd) {
+  try {
+    return clampIndex(readFileSync(memoryIndexPath(cwd), 'utf8'));
+  } catch {
+    return '';
+  }
+}
+
+/** Lista los temas (sin el índice). */
+export function listMemoryTopics(cwd) {
+  const root = memoryRoot(cwd);
+  let entries = [];
+  try {
+    entries = readdirSync(root, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const topics = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !isMemoryTopic(entry.name)) continue;
+    const file = path.join(root, entry.name);
+    let bytes = 0;
+    let mtime = 0;
+    let title = entry.name.replace(/\.md$/i, '');
+    let summary = '';
+    try {
+      const st = statSync(file);
+      bytes = st.size;
+      mtime = st.mtimeMs;
+      const text = readFileSync(file, 'utf8');
+      title = headingOf(text) || title;
+      summary = firstLine(text.replace(/^#.*$/m, ''));
+    } catch {
+      /* ignore */
+    }
+    topics.push({ name: entry.name, title, summary, bytes, mtime });
+  }
+  return topics.sort((a, b) => a.name.localeCompare(b.name, 'es'));
+}
+
+export function readMemoryTopic(cwd, name) {
+  if (!isMemoryTopic(name)) return null;
+  const file = path.join(memoryRoot(cwd), name);
+  try {
+    const raw = readFileSync(file, 'utf8');
+    return {
+      name,
+      title: headingOf(raw) || name.replace(/\.md$/i, ''),
+      body: raw.slice(0, MAX_TOPIC_BYTES),
+      truncated: Buffer.byteLength(raw, 'utf8') > MAX_TOPIC_BYTES,
+    };
+  } catch {
+    return null;
+  }
+}
+
+async function writeIndexBody(cwd, lines) {
+  const root = memoryRoot(cwd);
+  await mkdir(root, { recursive: true });
+  const body = ['# Memoria del proyecto', '', ...lines.filter(Boolean)].join('\n');
+  await writeFile(memoryIndexPath(cwd), `${clampIndex(body)}\n`, 'utf8');
+}
+
+function indexLines(existing) {
+  return String(existing ?? '')
+    .split(/\r?\n/)
+    .filter((l) => /^\s*[-*]\s/.test(l));
+}
+
+/** Fija (o agrega) la línea del tema en el índice. */
+async function upsertIndexLine(cwd, { name, title, summary }) {
+  const line = `- [${title}](${name})${summary ? ` — ${summary}` : ''}`;
+  const existing = indexLines(readMemoryIndex(cwd)).filter((l) => !l.includes(`(${name})`));
+  existing.push(line);
+  await writeIndexBody(cwd, existing);
+}
+
+async function removeIndexLine(cwd, name) {
+  const existing = indexLines(readMemoryIndex(cwd));
+  const next = existing.filter((l) => !l.includes(`(${name})`));
+  if (next.length !== existing.length) await writeIndexBody(cwd, next);
+}
+
+/** Escribe un tema (y su línea en el índice). Devuelve `{ name, title }`. */
+export async function writeMemory(cwd, { topic, title, content } = {}) {
+  const slug = memorySlug(topic ?? title);
+  if (!slug) throw new Error('Tema de memoria inválido.');
+  const name = `${slug}.md`;
+  if (!isMemoryTopic(name)) throw new Error('Tema de memoria inválido.');
+  const clean = String(content ?? '').trim();
+  if (!clean) throw new Error('El contenido de la memoria está vacío.');
+  const named = title ? String(title).trim() : slug;
+  const hasHeading = /^#\s/.test(clean);
+  const body = hasHeading ? clean : `# ${named}\n\n${clean}`;
+  const root = memoryRoot(cwd);
+  await mkdir(root, { recursive: true });
+  await writeFile(path.join(root, name), `${body.slice(0, MAX_TOPIC_BYTES)}\n`, 'utf8');
+  await upsertIndexLine(cwd, { name, title: named, summary: firstLine(clean) });
+  return { name, title: named };
+}
+
+export async function deleteMemory(cwd, name) {
+  if (!isMemoryTopic(name)) return false;
+  await rm(path.join(memoryRoot(cwd), name), { force: true });
+  await removeIndexLine(cwd, name);
+  return true;
+}
+
+/** Guarda el índice completo (`MEMORY.md`), acotado. */
+export async function writeIndex(cwd, content) {
+  const root = memoryRoot(cwd);
+  await mkdir(root, { recursive: true });
+  await writeFile(memoryIndexPath(cwd), `${clampIndex(String(content ?? ''))}\n`, 'utf8');
+}
+
+/** Busca `query` (case-insensitive) en índice y temas. */
+export function searchMemory(cwd, query) {
+  const needle = String(query ?? '').trim().toLowerCase();
+  if (!needle) return [];
+  const results = [];
+  const index = readMemoryIndex(cwd);
+  if (index.toLowerCase().includes(needle)) {
+    results.push({ name: MEMORY_INDEX_NAME, title: 'Índice', snippet: snippetAround(index, needle) });
+  }
+  for (const topic of listMemoryTopics(cwd)) {
+    const read = readMemoryTopic(cwd, topic.name);
+    if (!read) continue;
+    if (read.body.toLowerCase().includes(needle)) {
+      results.push({ name: topic.name, title: read.title, snippet: snippetAround(read.body, needle) });
+    }
+  }
+  return results;
+}
+
+function snippetAround(text, needle, radius = 120) {
+  const at = text.toLowerCase().indexOf(needle);
+  if (at < 0) return text.slice(0, radius * 2);
+  const start = Math.max(0, at - radius);
+  return text.slice(start, at + needle.length + radius).replace(/\s+/g, ' ').trim();
+}
+
+/**
+ * Bloque de system prompt con la memoria del proyecto (índice + temas), acotado.
+ * '' si no hay nada.
+ */
+export function memoryPrompt(cwd) {
+  const index = readMemoryIndex(cwd).trim();
+  const topics = listMemoryTopics(cwd);
+  if (!index && !topics.length) return '';
+  const lines = [
+    '## Memoria del proyecto',
+    'Lo que ya sabés de este proyecto (de sesiones anteriores). Mantenela con la herramienta `memory`; no hace falta repetirla.',
+  ];
+  if (index) lines.push('', index);
+  else if (topics.length) lines.push('', ...topics.map((t) => `- [${t.title}](${t.name})${t.summary ? ` — ${t.summary}` : ''}`));
+  return lines.join('\n');
+}

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

@@ -0,0 +1,151 @@
+// Reglas de proyecto por path: archivos `.md` con frontmatter `paths:` (globs).
+// 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 path from 'node:path';
+import { globToRegExp } from '../tools/glob.js';
+
+/** Parsea un archivo de reglas: frontmatter (name, paths/globs) + body. */
+export function parseRuleMarkdown(text, fallbackId = '') {
+  const source = String(text ?? '');
+  let name = fallbackId;
+  let paths = [];
+  let body = source.trim();
+  const match = source.match(/^---\s*\r?\n([\s\S]*?)\r?\n---\s*\r?\n?([\s\S]*)$/);
+  if (match) {
+    body = match[2].trim();
+    for (const line of match[1].split(/\r?\n/)) {
+      const kv = line.match(/^([A-Za-z][\w-]*)\s*:\s*(.*)$/);
+      if (!kv) continue;
+      const key = kv[1].toLowerCase();
+      const value = kv[2].trim();
+      if (key === 'name') name = value.replace(/^["']|["']$/g, '');
+      else if (key === 'paths' || key === 'globs' || key === 'path') paths = parseList(value);
+    }
+  }
+  return { name: name || fallbackId, paths: normalizePaths(paths), body };
+}
+
+function parseList(value) {
+  const raw = String(value ?? '').trim();
+  if (!raw) return [];
+  const inner = raw.startsWith('[') && raw.endsWith(']') ? raw.slice(1, -1) : raw;
+  return inner
+    .split(',')
+    .map((s) => s.trim().replace(/^["']|["']$/g, ''))
+    .filter(Boolean);
+}
+
+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)) {
+    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 && 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));
+}
+
+/** Reglas sin `paths` (aplican siempre). */
+export function staticRules(rules = []) {
+  return rules.filter((r) => !r.paths?.length);
+}
+
+/** Reglas con `paths` (contextuales). */
+export function pathRules(rules = []) {
+  return rules.filter((r) => r.paths?.length);
+}
+
+/** ¿La regla aplica a `relPath`? */
+export function ruleMatchesPath(rule, relPath) {
+  const rel = String(relPath ?? '').replace(/\\/g, '/').replace(/^\.?\//, '');
+  if (!rel) return false;
+  return (rule.paths ?? []).some((pattern) => globToRegExp(pattern).test(rel));
+}
+
+/** Reglas contextuales que aplican a `relPath`. */
+export function rulesForPath(rules, relPath) {
+  return pathRules(rules).filter((r) => ruleMatchesPath(r, relPath));
+}
+
+/** Bloque de system prompt con reglas estáticas. */
+export function buildStaticRulesBlock(rules) {
+  const list = staticRules(rules);
+  if (!list.length) return '';
+  const parts = ['## Reglas del proyecto'];
+  for (const rule of list) parts.push('', rule.body);
+  return parts.join('\n');
+}
+
+/** Bloque inyectable con las reglas que aplican a un archivo. */
+export function buildPathRulesBlock(rules, relPath) {
+  if (!rules.length) return '';
+  const parts = [`## Reglas del proyecto para ${relPath}`];
+  for (const rule of rules) parts.push('', rule.body);
+  return parts.join('\n');
+}

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

@@ -0,0 +1,96 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import {
+  memoryRoot,
+  memorySlug,
+  isMemoryTopic,
+  readMemoryIndex,
+  listMemoryTopics,
+  readMemoryTopic,
+  writeMemory,
+  writeIndex as writeMemoryIndex,
+  deleteMemory,
+  searchMemory,
+  memoryPrompt,
+} from '../src/memory/index.js';
+
+async function workspace() {
+  return mkdtemp(path.join(tmpdir(), 'tamnora-memory-'));
+}
+
+test('memorySlug / isMemoryTopic normalize names', () => {
+  assert.equal(memorySlug('Revisión de PR!'), 'revisi-n-de-pr');
+  assert.equal(isMemoryTopic('build.md'), true);
+  assert.equal(isMemoryTopic('MEMORY.md'), false);
+  assert.equal(isMemoryTopic('../evil.md'), false);
+  assert.equal(isMemoryTopic('note.txt'), false);
+});
+
+test('writeMemory creates a topic file and an index line', async () => {
+  const cwd = await workspace();
+  const saved = await writeMemory(cwd, { topic: 'arquitectura', title: 'Arquitectura', content: 'Usa SQLite.' });
+  assert.equal(saved.name, 'arquitectura.md');
+
+  const file = await readFile(path.join(memoryRoot(cwd), 'arquitectura.md'), 'utf8');
+  assert.match(file, /# Arquitectura/);
+  assert.match(file, /Usa SQLite\./);
+
+  const index = readMemoryIndex(cwd);
+  assert.match(index, /arquitectura\.md/);
+  assert.match(index, /Arquitectura/);
+
+  const topics = listMemoryTopics(cwd);
+  assert.deepEqual(topics.map((t) => t.name), ['arquitectura.md']);
+  assert.equal(topics[0].title, 'Arquitectura');
+});
+
+test('upsert keeps a single index line per topic', async () => {
+  const cwd = await workspace();
+  await writeMemory(cwd, { topic: 'deploy', content: 'primero' });
+  await writeMemory(cwd, { topic: 'deploy', content: 'segundo' });
+  const lines = readMemoryIndex(cwd)
+    .split(/\r?\n/)
+    .filter((l) => l.includes('deploy.md'));
+  assert.equal(lines.length, 1);
+});
+
+test('readMemoryTopic returns null for invalid names', async () => {
+  const cwd = await workspace();
+  assert.equal(readMemoryTopic(cwd, '../x.md'), null);
+  assert.equal(readMemoryTopic(cwd, 'missing.md'), null);
+});
+
+test('deleteMemory removes the file and its index line', async () => {
+  const cwd = await workspace();
+  await writeMemory(cwd, { topic: 'temp', content: 'algo' });
+  assert.equal(await deleteMemory(cwd, 'temp.md'), true);
+  assert.equal(readMemoryTopic(cwd, 'temp.md'), null);
+  assert.doesNotMatch(readMemoryIndex(cwd), /temp\.md/);
+});
+
+test('writeMemoryIndex replaces the whole index (capped)', async () => {
+  const cwd = await workspace();
+  await writeMemoryIndex(cwd, '# Memoria\n\n- a\n- b');
+  assert.match(readMemoryIndex(cwd), /- a/);
+});
+
+test('searchMemory finds matches in index and topics', async () => {
+  const cwd = await workspace();
+  await writeMemory(cwd, { topic: 'api', content: 'El endpoint es /v1/lento.' });
+  const hits = searchMemory(cwd, 'lento');
+  assert.ok(hits.some((h) => h.name === 'api.md'));
+  assert.ok(hits.every((h) => /lento/.test(h.snippet)));
+  assert.deepEqual(searchMemory(cwd, 'inexistente'), []);
+});
+
+test('memoryPrompt is empty without memory and includes the index otherwise', async () => {
+  const cwd = await workspace();
+  assert.equal(memoryPrompt(cwd), '');
+  await writeMemory(cwd, { topic: 'notas', title: 'Notas', content: 'Recordar X.' });
+  const prompt = memoryPrompt(cwd);
+  assert.match(prompt, /Memoria del proyecto/);
+  assert.match(prompt, /notas\.md/);
+});

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

@@ -0,0 +1,64 @@
+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 {
+  parseRuleMarkdown,
+  loadRules,
+  staticRules,
+  pathRules,
+  ruleMatchesPath,
+  rulesForPath,
+  buildStaticRulesBlock,
+  buildPathRulesBlock,
+} from '../src/rules/index.js';
+
+test('parseRuleMarkdown reads paths and body', () => {
+  const rule = parseRuleMarkdown('---\nname: Estilo\npaths: ["src/**/*.js", "lib/*.ts"]\n---\nUsá comillas simples.', 'x');
+  assert.equal(rule.name, 'Estilo');
+  assert.deepEqual(rule.paths, ['src/**/*.js', 'lib/*.ts']);
+  assert.match(rule.body, /comillas simples/);
+
+  const plain = parseRuleMarkdown('Sin frontmatter.', 'y');
+  assert.deepEqual(plain.paths, []);
+  assert.equal(plain.body, 'Sin frontmatter.');
+});
+
+test('ruleMatchesPath uses glob semantics', () => {
+  const rule = { paths: ['src/**/*.js', 'docs/*.md'] };
+  assert.equal(ruleMatchesPath(rule, 'src/a/b.js'), true);
+  assert.equal(ruleMatchesPath(rule, 'src/a/b.ts'), false);
+  assert.equal(ruleMatchesPath(rule, 'docs/guia.md'), true);
+  assert.equal(ruleMatchesPath(rule, 'docs/sub/guia.md'), false);
+});
+
+test('loadRules scans glob patterns and splits static/path rules', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-rules-'));
+  await mkdir(path.join(cwd, '.tamnora', 'rules'), { recursive: true });
+  await writeFile(
+    path.join(cwd, '.tamnora', 'rules', 'estilo.md'),
+    '---\npaths: src/**\n---\n# Estilo\nUsá punto y coma.'
+  );
+  await writeFile(path.join(cwd, '.tamnora', 'rules', 'general.md'), '# General\nSé conciso.');
+
+  const rules = await loadRules(cwd, ['.tamnora/rules/*.md']);
+  assert.equal(rules.length, 2);
+  assert.equal(staticRules(rules).length, 1);
+  assert.equal(pathRules(rules).length, 1);
+
+  const matched = rulesForPath(rules, 'src/index.js');
+  assert.equal(matched.length, 1);
+  assert.match(matched[0].body, /punto y coma/);
+});
+
+test('buildStaticRulesBlock and buildPathRulesBlock render bodies', () => {
+  const rules = [
+    { id: 'a', paths: [], body: 'Sé conciso.' },
+    { id: 'b', paths: ['src/**'], body: 'Usá 2 espacios.' },
+  ];
+  assert.equal(buildStaticRulesBlock([]), '');
+  assert.match(buildStaticRulesBlock(rules), /Sé conciso\./);
+  assert.doesNotMatch(buildStaticRulesBlock(rules), /2 espacios/);
+  assert.match(buildPathRulesBlock([rules[1]], 'src/x.js'), /2 espacios/);
+});