@danieltmn/tamnora 0.11.3 → 0.13.0

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/providers/cache.js

@@ -0,0 +1,29 @@
+// Prompt caching. `mode` es una capability del provider:
+//  - 'anthropic': marca el system prompt con cache_control (OpenRouter y la capa
+//    OpenAI-compatible de Anthropic aceptan bloques de contenido con cache_control).
+//  - 'openai': expone una clave estable para el cacheo automático de prefijos.
+// Es opt-in: sin `promptCaching` en la config, no se toca nada.
+
+import { createHash } from 'node:crypto';
+
+/** Clave estable (system + tools) para el cacheo automático de OpenAI. */
+export function promptCacheKey(messages = [], tools = []) {
+  const base = JSON.stringify([messages?.[0]?.content ?? '', tools ?? []]);
+  return createHash('sha1').update(base).digest('hex').slice(0, 32);
+}
+
+/** Aplica las pistas de cache al body (muta y devuelve `body`). */
+export function applyPromptCache(body, { mode = 'none' } = {}) {
+  if (mode === 'anthropic' && Array.isArray(body.messages) && body.messages.length) {
+    const first = body.messages[0];
+    if (first?.role === 'system' && typeof first.content === 'string') {
+      body.messages = [
+        { ...first, content: [{ type: 'text', text: first.content, cache_control: { type: 'ephemeral' } }] },
+        ...body.messages.slice(1),
+      ];
+    }
+  } else if (mode === 'openai') {
+    body.prompt_cache_key = promptCacheKey(body.messages, body.tools);
+  }
+  return body;
+}

package/harness/packages/core/src/providers/ollama.js

@@ -52,9 +52,10 @@ export const ollamaProvider = {
     return sortModels((data.models ?? []).map(toOllamaModel).filter((m) => m.id));
   },
 
-  async streamChat({ baseUrl }, { model, messages, tools, signal, onEvent }) {
+  async streamChat({ baseUrl }, { model, messages, tools, signal, onEvent, maxOutputTokens }) {
     const body = { model, messages: toOllamaMessages(messages), stream: true };
     if (tools?.length) body.tools = tools;
+    if (maxOutputTokens > 0) body.options = { ...(body.options ?? {}), num_predict: maxOutputTokens };
 
     const res = await providerFetch(joinUrl(baseUrl, '/api/chat'), {
       method: 'POST',
@@ -71,6 +72,6 @@ export const ollamaProvider = {
       });
     }
 
-    return readNDJSON(res, { onEvent });
+    return readNDJSON(res, { onEvent, signal });
   },
 };

package/harness/packages/core/src/providers/openaiCompatible.js

@@ -1,4 +1,5 @@
 import { readOpenAISSE } from './stream.js';
+import { applyPromptCache } from './cache.js';
 import { joinUrl, authHeaders, providerError, providerFetch, normalizeModel, sortModels } from './utils.js';
 
 /**
@@ -21,9 +22,15 @@ export const openaiCompatibleProvider = {
     return sortModels(list.map(normalizeModel).filter((m) => m.id));
   },
 
-  async streamChat({ baseUrl, apiKey, headers }, { model, messages, tools, signal, onEvent }) {
+  async streamChat({ baseUrl, apiKey, headers }, { model, messages, tools, signal, onEvent, maxOutputTokens, promptCaching }) {
     const body = { model, messages, stream: true };
     if (tools?.length) body.tools = tools;
+    if (maxOutputTokens > 0) {
+      // OpenAI o-series exige `max_completion_tokens`; el resto usa `max_tokens`.
+      const field = this?.maxTokensField ?? 'max_tokens';
+      body[field] = maxOutputTokens;
+    }
+    if (promptCaching) applyPromptCache(body, { mode: this?.caching ?? 'none' });
 
     return requestStream({
       url: joinUrl(baseUrl, '/chat/completions'),
@@ -53,5 +60,5 @@ export async function requestStream({ url, headers, providerLabel, model, body,
     });
   }
 
-  return readOpenAISSE(res, { onEvent });
+  return readOpenAISSE(res, { onEvent, signal });
 }

package/harness/packages/core/src/providers/openrouter.js

@@ -1,4 +1,5 @@
 import { requestStream } from './openaiCompatible.js';
+import { applyPromptCache } from './cache.js';
 import { joinUrl, providerFetch, normalizeModel, sortModels } from './utils.js';
 
 const OPENROUTER_BASE_URL = 'https://openrouter.ai/api/v1';
@@ -21,6 +22,8 @@ export const openrouterProvider = {
   label: 'OpenRouter',
   defaultBaseUrl: OPENROUTER_BASE_URL,
   requiresKey: true,
+  // OpenRouter pasa cache_control a Anthropic; en otros modelos queda sin efecto.
+  caching: 'anthropic',
 
   async listModels({ apiKey, siteUrl, siteName }) {
     const res = await providerFetch(joinUrl(OPENROUTER_BASE_URL, '/models'), {
@@ -40,9 +43,11 @@ export const openrouterProvider = {
     );
   },
 
-  async streamChat(ctx, { model, messages, tools, signal, onEvent }) {
+  async streamChat(ctx, { model, messages, tools, signal, onEvent, maxOutputTokens, promptCaching }) {
     const body = { model, messages, stream: true };
     if (tools?.length) body.tools = tools;
+    if (maxOutputTokens > 0) body.max_tokens = maxOutputTokens;
+    if (promptCaching) applyPromptCache(body, { mode: this?.caching ?? 'none' });
 
     return requestStream({
       url: joinUrl(OPENROUTER_BASE_URL, '/chat/completions'),

package/harness/packages/core/src/providers/presets.js

@@ -2,16 +2,19 @@ import { openaiCompatibleProvider } from './openaiCompatible.js';
 
 // Most commercial providers expose an OpenAI-compatible chat completions API,
 // so they only differ by label and base URL. Adding one is a one-liner.
-function preset(id, label, baseUrl) {
-  return { ...openaiCompatibleProvider, id, label, defaultBaseUrl: baseUrl, requiresKey: true };
+function preset(id, label, baseUrl, extra = {}) {
+  return { ...openaiCompatibleProvider, id, label, defaultBaseUrl: baseUrl, requiresKey: true, ...extra };
 }
 
 export const OPENAI_COMPATIBLE_PRESETS = [
   preset('deepseek', 'DeepSeek', 'https://api.deepseek.com/v1'),
-  preset('openai', 'OpenAI', 'https://api.openai.com/v1'),
+  preset('openai', 'OpenAI', 'https://api.openai.com/v1', {
+    maxTokensField: 'max_completion_tokens',
+    caching: 'openai',
+  }),
   // Anthropic y Gemini exponen una capa compatible con OpenAI (chat/completions
   // + tools) que usa el mismo Bearer; sirven con este adaptador sin cambios.
-  preset('anthropic', 'Anthropic (Claude)', 'https://api.anthropic.com/v1'),
+  preset('anthropic', 'Anthropic (Claude)', 'https://api.anthropic.com/v1', { caching: 'anthropic' }),
   preset('gemini', 'Google Gemini', 'https://generativelanguage.googleapis.com/v1beta/openai'),
   preset('groq', 'Groq', 'https://api.groq.com/openai/v1'),
   preset('mistral', 'Mistral AI', 'https://api.mistral.ai/v1'),

package/harness/packages/core/src/providers/stream.js

@@ -9,6 +9,47 @@
  * string or as an object (`message`, `data.message`, serialized `data`).
  * (openbridge-style tolerance: errors come in many shapes per provider.)
  */
+function abortError() {
+  return new DOMException('Aborted', 'AbortError');
+}
+
+/**
+ * `reader.read()` abortable. Aunque `fetch` deberia cancelar el body al abortar,
+ * no todos los runtimes lo hacen de forma inmediata; esto garantiza que el
+ * stream se corte apenas el usuario detiene el run.
+ */
+function readChunk(reader, signal) {
+  if (!signal) return reader.read();
+  if (signal.aborted) {
+    reader.cancel().catch(() => {});
+    return Promise.reject(abortError());
+  }
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const onAbort = () => {
+      if (settled) return;
+      settled = true;
+      reader.cancel().catch(() => {});
+      reject(abortError());
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
+    reader.read().then(
+      (result) => {
+        if (settled) return;
+        settled = true;
+        signal.removeEventListener('abort', onAbort);
+        resolve(result);
+      },
+      (error) => {
+        if (settled) return;
+        settled = true;
+        signal.removeEventListener('abort', onAbort);
+        reject(error);
+      }
+    );
+  });
+}
+
 export function providerErrorMessage(payload) {
   const err = typeof payload === 'string' ? payload : (payload?.error ?? payload);
   if (typeof err === 'string' && err) return err;
@@ -39,7 +80,7 @@ export function providerErrorMessage(payload) {
  * Parse an OpenAI-compatible SSE stream.
  * @returns {Promise<{content:string, reasoning:string, toolCalls:object[], usage:object|null}>}
  */
-export async function readOpenAISSE(response, { onEvent } = {}) {
+export async function readOpenAISSE(response, { onEvent, signal } = {}) {
   const reader = response.body.getReader();
   const decoder = new TextDecoder('utf-8');
   let partial = '';
@@ -50,7 +91,7 @@ export async function readOpenAISSE(response, { onEvent } = {}) {
   let usage = null;
 
   while (true) {
-    const { done, value } = await reader.read();
+    const { done, value } = await readChunk(reader, signal);
     if (done) break;
     partial += decoder.decode(value, { stream: true });
     const lines = partial.split('\n');
@@ -108,7 +149,7 @@ export async function readOpenAISSE(response, { onEvent } = {}) {
  * Parse Ollama's native NDJSON stream (`/api/chat`).
  * @returns {Promise<{content:string, reasoning:string, toolCalls:object[], usage:object|null}>}
  */
-export async function readNDJSON(response, { onEvent } = {}) {
+export async function readNDJSON(response, { onEvent, signal } = {}) {
   const reader = response.body.getReader();
   const decoder = new TextDecoder('utf-8');
   let partial = '';
@@ -155,7 +196,7 @@ export async function readNDJSON(response, { onEvent } = {}) {
   };
 
   while (true) {
-    const { done, value } = await reader.read();
+    const { done, value } = await readChunk(reader, signal);
     if (done) break;
     partial += decoder.decode(value, { stream: true });
     const lines = partial.split('\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/src/skills/index.js

@@ -77,6 +77,27 @@ export async function writeSkillFiles(dir, files = []) {
   }
 }
 
+const INDEX_WHEN_CHARS = 220;
+
+/**
+ * Índice compacto (name + when/description, sin body) para *progressive
+ * disclosure*: el modelo ve qué skills hay y carga el body on-demand con la
+ * herramienta `skill`. Mucho más barato en tokens que inyectar todos los bodies.
+ */
+export function buildSkillsIndex(skills = []) {
+  if (!skills.length) return '';
+  const lines = [
+    'Tenés skills disponibles (instrucciones especializadas). Cuando una aplique a la tarea, cargá su contenido con la herramienta `skill({ name })`:',
+  ];
+  for (const skill of skills) {
+    const title = skill.name || skill.id;
+    const when = String(skill.when || skill.description || '').replace(/\s+/g, ' ').trim();
+    const hint = when.length > INDEX_WHEN_CHARS ? `${when.slice(0, INDEX_WHEN_CHARS)}…` : when;
+    lines.push(`- ${skill.id}: ${title}${hint ? ` — ${hint}` : ''}`);
+  }
+  return lines.join('\n');
+}
+
 /** Text block appended to the system prompt with the enabled skills. */
 export function buildSkillsPrompt(skills = []) {
   if (!skills.length) return '';

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

@@ -301,12 +301,16 @@ export async function grepTool(root, { pattern, include, path: p } = {}) {
   return results.length ? results.join('\n') : 'Sin coincidencias';
 }
 
-export function bashTool(root, { command, timeout } = {}) {
+export function bashTool(root, { command, timeout } = {}, { signal } = {}) {
   return new Promise((resolve) => {
     if (!command || typeof command !== 'string') {
       resolve('Error: falta "command".');
       return;
     }
+    if (signal?.aborted) {
+      resolve('Comando cancelado por el usuario.');
+      return;
+    }
     const seconds = Math.min(Math.max(Number(timeout) || 30, 1), 300);
     let child;
     try {
@@ -318,31 +322,35 @@ export function bashTool(root, { command, timeout } = {}) {
 
     let output = '';
     let settled = false;
+    let timer = null;
     const append = (chunk) => {
       if (output.length < MAX_BASH_OUTPUT) output += chunk.toString();
     };
 
-    const timer = setTimeout(() => {
+    const finish = (text) => {
       if (settled) return;
       settled = true;
+      if (timer) clearTimeout(timer);
+      signal?.removeEventListener('abort', onAbort);
+      resolve(text);
+    };
+    const onAbort = () => {
       child.kill('SIGKILL');
-      resolve(`${output}\n[timeout tras ${seconds}s]\n[exit -1]`);
+      finish(`${output}\n[comando cancelado por el usuario]\n[exit -1]`);
+    };
+    signal?.addEventListener('abort', onAbort, { once: true });
+
+    timer = setTimeout(() => {
+      child.kill('SIGKILL');
+      finish(`${output}\n[timeout tras ${seconds}s]\n[exit -1]`);
     }, seconds * 1000);
 
     child.stdout?.on('data', append);
     child.stderr?.on('data', append);
-    child.on('error', (err) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolve(`Error ejecutando el comando: ${err.message}`);
-    });
+    child.on('error', (err) => finish(`Error ejecutando el comando: ${err.message}`));
     child.on('close', (code) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
       const truncated = output.length >= MAX_BASH_OUTPUT ? '\n[output truncado]' : '';
-      resolve(`${output}${truncated}\n[exit ${code}]`);
+      finish(`${output}${truncated}\n[exit ${code}]`);
     });
   });
 }