@danieltmn/tamnora 0.11.2 → 0.12.0

package/CHANGELOG.md

@@ -5,6 +5,37 @@ 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.12.0] - 2026-10-10
+
+### Agregado
+
+- **Fase 1 del roadmap del server (contexto y costo)**:
+  - **Skills on-demand**: se inyecta un índice (`name` + `when`) y el modelo carga
+    el cuerpo con la tool `skill({ name })`. Config `skills.mode: lazy|eager`
+    (lazy por defecto). Ahorra tokens en cada turno.
+  - **`max_tokens` por ronda** (`maxOutputTokens`; 0 = default del proveedor), en
+    providers, `/api/settings` y CLI.
+  - **Prompt caching opt-in** (`promptCaching`): `cache_control` para Anthropic
+    (OpenRouter/Anthropic) y `prompt_cache_key` para OpenAI.
+  - **Auto-compactación** (`compact: { enabled, threshold: 0.75, keepLast: 8 }`):
+    resume lo viejo y lo reemplaza por `meta.summary` + `meta.summaryCursor` sin
+    borrar el historial. Evento `compacted`.
+  - **Seam de ciclo de vida** en `runAgent` (`run.start/end`, `tool.before/after`),
+    base para checkpoints y hooks.
+
+### Arreglado
+
+- `trimContext` ya no descarta el objetivo/resumen de la sesión al recortar
+  (protege los mensajes system iniciales).
+- `effectiveStrictScope` no se exponía en `ctx`, lo que rompía `GET /api/settings`.
+
+## [0.11.3] - 2026-10-09
+
+### Cambios
+
+- feat(consola): sidebar, estructura y vista previa de codigo
+- docs(website): iconos y logo en la landing (favicon + header/footer)
+
 ## [0.11.2] - 2026-10-09
 
 ### Arreglado

package/README.md

@@ -52,6 +52,8 @@ Atajos: `enter` enviar · `↑/↓` historial · `←/→` cursor · `home/end`
 `/limpiar`. El pegado de bloques multilinea entra como un solo texto y el header
 muestra el contexto usado (`ctx <tokens>`). Las tools `write`/`edit` muestran un
 **diff lado a lado** (viejo en rojo, nuevo en verde, con numeros de linea).
+`/estricto` (o `--strict`) prende el modo **solo lo pedido**: el agente hace
+exactamente lo que pedis, sin refactors ni cambios fuera del pedido.
 
 ### Server como servicio
 
@@ -106,7 +108,11 @@ menu "mas" (los tres puntitos). En el chat:
   menu `⋮`; el indicador de "pensando/trabajando" vive en el pie (`#sb-activity`).
 - **Runs durables**: cerrar el celular o cortar la red **no cancela** el turno; al
   volver, la consola **reconecta** y reconstruye el progreso. Para cortarlo se usa
-  el boton de detener (o `POST /api/sessions/:id/stop`).
+  el boton de detener (o `POST /api/sessions/:id/stop`), que ademas corta el stream
+  del modelo y mata las tools de larga duracion (p. ej. `bash`) en curso.
+- **Solo lo pedido (estricto)**: el toggle de la pestaña Agente (o `PUT
+  /api/settings` con `strictScope`) hace que el agente se limite a lo solicitado,
+  sin mejoras ni cambios extra; se combina con Plan o Build.
 - **Audio**: un unico reproductor encola la narracion, el tool `speak`, la
   respuesta final y los consejos del asesor, y reproduce de a uno con pausa y
   detener (Ajustes -> Voz).

package/harness/packages/cli/src/commands/repl.js

@@ -6,6 +6,7 @@ import {
   Store,
   createTools,
   buildMcpRegistry,
+  scopeDirective,
 } from '../lib/core.js';
 import { parse, databasePath, num } from '../lib/util.js';
 import { buildSystemPrompt, runTurn, createPrinter, resolveCliProvider } from '../lib/runtime.js';
@@ -18,6 +19,8 @@ const OPTIONS = {
   'max-steps': { type: 'string' },
   tools: { type: 'string' },
   'no-tools': { type: 'boolean' },
+  strict: { type: 'boolean' },
+  'no-strict': { type: 'boolean' },
   yes: { type: 'boolean', short: 'y' },
 };
 
@@ -26,9 +29,13 @@ export async function replCommand(argv) {
   const cwd = values.dir ? path.resolve(values.dir) : process.cwd();
   const config = await loadConfig(cwd);
 
-  let systemPrompt = buildSystemPrompt(await loadInstructions(cwd, config.instructions));
+  const instructions = await loadInstructions(cwd, config.instructions);
+  let systemExtra = '';
   const maxRounds = num(values['max-steps'], config.maxRounds);
   const store = new Store(databasePath(cwd));
+  let strict = values.strict ? true : values['no-strict'] ? false : store.getSetting('strictScope') === true;
+  const buildPrompt = () =>
+    buildSystemPrompt(instructions, [systemExtra, scopeDirective(strict)].filter(Boolean).join('\n\n'));
   const resolved = resolveCliProvider(store, config, { provider: values.provider, model: values.model });
   let providerId = resolved.providerId;
   let model = resolved.model;
@@ -108,7 +115,7 @@ export async function replCommand(argv) {
       } else if (cmd === 'help') {
         process.stdout.write(
           `${color.dim(
-            '/model <id>  /provider <id>  /system <texto>  /clear  /session  /exit'
+            '/model <id>  /provider <id>  /system <texto>  /strict  /clear  /session  /exit'
           )}\n`
         );
       } else if (cmd === 'model') {
@@ -118,8 +125,13 @@ export async function replCommand(argv) {
         if (arg) providerId = arg;
         process.stdout.write(color.dim(`proveedor: ${providerId}\n`));
       } else if (cmd === 'system') {
-        if (arg) systemPrompt = arg;
-        process.stdout.write(color.dim(`system prompt (${systemPrompt.length} chars)\n`));
+        if (arg) systemExtra = arg;
+        process.stdout.write(color.dim(`system prompt (${buildPrompt().length} chars)\n`));
+      } else if (cmd === 'strict' || cmd === 'estricto') {
+        if (arg) strict = /^(on|si|sí|1|true)$/i.test(arg);
+        else strict = !strict;
+        store.setSetting('strictScope', strict);
+        process.stdout.write(color.dim(`solo lo pedido: ${strict ? 'activado' : 'desactivado'}\n`));
       } else if (cmd === 'clear') {
         history = [];
         process.stdout.write(color.dim('historial limpiado\n'));
@@ -142,12 +154,13 @@ export async function replCommand(argv) {
         baseUrl,
         apiKey,
         customProviders,
-        systemPrompt,
+        systemPrompt: buildPrompt(),
         history,
         input: text,
         maxRounds,
         maxTokens: config.maxTokens,
         maxDurationMs: config.maxDurationMs,
+        maxOutputTokens: config.maxOutputTokens,
         tools: toolDefs,
         execute,
         onEvent: printer.onEvent,

package/harness/packages/cli/src/commands/run.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { loadConfig, loadInstructions, Store, createTools, buildMcpRegistry } from '../lib/core.js';
+import { loadConfig, loadInstructions, Store, createTools, buildMcpRegistry, scopeDirective } from '../lib/core.js';
 import { parse, databasePath, num } from '../lib/util.js';
 import { buildSystemPrompt, runTurn, createPrinter, resolveCliProvider } from '../lib/runtime.js';
 import { color } from '../ui/color.js';
@@ -15,6 +15,8 @@ const OPTIONS = {
   system: { type: 'string' },
   tools: { type: 'string' },
   'no-tools': { type: 'boolean' },
+  strict: { type: 'boolean' },
+  'no-strict': { type: 'boolean' },
   yes: { type: 'boolean', short: 'y' },
   help: { type: 'boolean', short: 'h' },
 };
@@ -95,6 +97,8 @@ export async function runCommand(argv) {
   const onSigint = () => controller.abort();
   process.once('SIGINT', onSigint);
 
+  const strict = values.strict ? true : values['no-strict'] ? false : store.getSetting('strictScope') === true;
+
   try {
     const { result, newMessages } = await runTurn({
       providerId,
@@ -102,12 +106,16 @@ export async function runCommand(argv) {
       baseUrl,
       apiKey,
       customProviders,
-      systemPrompt: buildSystemPrompt(instructions, values.system),
+      systemPrompt: buildSystemPrompt(
+        instructions,
+        [values.system, scopeDirective(strict)].filter(Boolean).join('\n\n')
+      ),
       history,
       input: prompt,
       maxRounds: num(values['max-steps'], config.maxRounds),
       maxTokens: config.maxTokens,
       maxDurationMs: config.maxDurationMs,
+      maxOutputTokens: config.maxOutputTokens,
       signal: controller.signal,
       tools: toolDefs,
       execute,
@@ -163,6 +171,7 @@ Opciones:
   --max-steps <n>    Techo de rondas de herramientas (0 = sin límite, default)
   --tools <lista>    Tools habilitadas (coma), ej. read,list,grep
   --no-tools         Deshabilitar todas las tools
+  --strict           Hacer solo lo pedido (estricto)   --no-strict
   -y, --yes          Aprobar automáticamente los permisos "ask"
   --json             Salida JSON (sin streaming)`);
 }

package/harness/packages/cli/src/commands/tui.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { loadConfig, loadInstructions, Store, buildMcpRegistry, resolveMode } from '../lib/core.js';
+import { loadConfig, loadInstructions, Store, buildMcpRegistry, resolveMode, scopeDirective } from '../lib/core.js';
 import { parse, databasePath, num } from '../lib/util.js';
 import { buildSystemPrompt, resolveCliProvider } from '../lib/runtime.js';
 import { runTui } from '../tui/app.js';
@@ -14,6 +14,8 @@ const OPTIONS = {
   system: { type: 'string' },
   tools: { type: 'string' },
   'no-tools': { type: 'boolean' },
+  strict: { type: 'boolean' },
+  'no-strict': { type: 'boolean' },
   yes: { type: 'boolean', short: 'y' },
   help: { type: 'boolean', short: 'h' },
 };
@@ -63,10 +65,11 @@ export async function tuiCommand(argv) {
         : undefined;
 
   const mode = resolveMode(values.mode || store.getSetting('activeMode') || 'agent');
+  let strict = values.strict ? true : values['no-strict'] ? false : store.getSetting('strictScope') === true;
   const enabledFor = (m) =>
     m.tools ? (baseEnabled ? baseEnabled.filter((tool) => m.tools.includes(tool)) : m.tools) : baseEnabled;
   const promptFor = (m) =>
-    buildSystemPrompt(instructions, [values.system, m.systemPrompt].filter(Boolean).join('\n\n'));
+    buildSystemPrompt(instructions, [values.system, m.systemPrompt, scopeDirective(strict)].filter(Boolean).join('\n\n'));
   const modeContext = (id) => {
     const m = resolveMode(id);
     return { label: m.label, enabled: enabledFor(m), systemPrompt: promptFor(m) };
@@ -83,10 +86,16 @@ export async function tuiCommand(argv) {
     modeId: mode.id,
     modeContext,
     onModeChange: (id) => store.setSetting('activeMode', id),
+    strict,
+    onStrictChange: (value) => {
+      strict = value;
+      store.setSetting('strictScope', value);
+    },
     systemPrompt: promptFor(mode),
     maxRounds: num(values['max-steps'], config.maxRounds),
     maxTokens: config.maxTokens,
     maxDurationMs: config.maxDurationMs,
+    maxOutputTokens: config.maxOutputTokens,
     toolOptions: {
       root: cwd,
       enabled: enabledFor(mode),
@@ -106,7 +115,7 @@ Consola full-screen (estilo opencode/codex). Atajos:
   enter      enviar        ↑ / ↓     historial
    ← → mover cursor  home/end  inicio / fin
    pgup/pgdn  scroll        ctrl+l    limpiar
-   ctrl+.     alternar Plan / Build   /modo  /salir  /limpiar
+   ctrl+.     alternar Plan / Build   /modo  /estricto  /salir  /limpiar
 
 Opciones:
   --provider <id>   Proveedor (por defecto: el activo)
@@ -115,5 +124,6 @@ Opciones:
   --dir <path>      Directorio del proyecto
   --max-steps <n>   Techo de rondas de herramientas (0 = sin límite, default)
   --tools <lista>   Tools habilitadas (coma)   --no-tools
+  --strict          Hacer solo lo pedido (estricto)   --no-strict
   -y, --yes         Auto-aprobar tools con permiso "ask"`);
 }

package/harness/packages/cli/src/lib/runtime.js

@@ -54,6 +54,7 @@ export async function runTurn({
   maxRounds,
   maxTokens,
   maxDurationMs,
+  maxOutputTokens,
   stallWarnMs,
   signal,
   execute,
@@ -80,6 +81,7 @@ export async function runTurn({
     maxRounds,
     maxTokens,
     maxDurationMs,
+    maxOutputTokens,
     stallWarnMs,
     signal,
     onEvent,

package/harness/packages/cli/src/tui/app.js

@@ -17,10 +17,13 @@ export function runTui({
   modeId = 'agent',
   modeContext,
   onModeChange,
+  strict = false,
+  onStrictChange,
   systemPrompt,
   maxRounds,
   maxTokens,
   maxDurationMs,
+  maxOutputTokens,
   toolOptions,
   store,
   sessionId,
@@ -101,6 +104,18 @@ export function runTui({
     draw();
   }
 
+  function setStrict(value) {
+    strict = value;
+    onStrictChange?.(value);
+    setMode(mode);
+  }
+
+  function toggleStrict(value) {
+    setStrict(value == null ? !strict : value);
+    addMessage('assistant', `Solo lo pedido: ${strict ? 'activado' : 'desactivado'}.`);
+    draw();
+  }
+
   function draw() {
     if (closed) return;
     const { frame, cursor } = render(state, {
@@ -153,6 +168,12 @@ export function runTui({
       draw();
       return;
     }
+    if (text === '/estricto' || text === '/strict') return toggleStrict();
+    const strictArg = text.match(/^\/(?:estricto|strict)\s+(on|off|si|sí|no)$/i);
+    if (strictArg) {
+      toggleStrict(/^(on|si|sí)$/i.test(strictArg[1]));
+      return;
+    }
     if (text === '/limpiar' || text === '/clear') {
       state.input = '';
       state.messages = [];
@@ -184,6 +205,7 @@ export function runTui({
         maxRounds,
         maxTokens,
         maxDurationMs,
+        maxOutputTokens,
         signal: controller.signal,
         tools: toolset.definitions,
         execute: toolset.execute,

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

@@ -0,0 +1,38 @@
+// Compactación de contexto (auto-compact). La lógica de decisión es pura y
+// testeable; la llamada al modelo para resumir vive en el server.
+
+import { estimateTokens } from './context.js';
+
+export const COMPACT_INSTRUCTION =
+  'Resumí la conversación en un texto conciso que preserve decisiones tomadas, archivos tocados, hallazgos y el estado actual, para poder continuar el trabajo sin el historial completo.';
+
+export const SUMMARY_INSTRUCTION =
+  'Resumí la conversación para la persona: qué se pidió, qué se hizo, decisiones tomadas, archivos o comandos relevantes y el estado actual. Sé claro y conciso, en español, sin markdown pesado.';
+
+/**
+ * Historial vigente: sin los mensajes del asesor ni lo ya resumido (anterior al
+ * cursor de compactación). Si el cursor no está (historial truncado), devuelve
+ * todo para no perder contexto.
+ */
+export function liveHistory(history = [], cursor = null) {
+  const filtered = history.filter((message) => message.name !== 'advisor');
+  if (!cursor) return filtered;
+  const idx = filtered.findIndex((message) => message.id === cursor);
+  return idx === -1 ? filtered : filtered.slice(idx + 1);
+}
+
+/**
+ * Decide si conviene compactar, sobre el historial vigente. Puro (no llama al
+ * modelo). Devuelve qué resumir, qué conservar y el cursor (id del último
+ * mensaje resumido), o `null` si no hace falta.
+ */
+export function planCompaction(live, { contextTokens = 0, threshold = 0.75, keepLast = 8 } = {}) {
+  if (!(contextTokens > 0)) return null;
+  const keep = Math.max(0, Number(keepLast) || 0);
+  if (!Array.isArray(live) || live.length <= keep + 2) return null;
+  if (estimateTokens(live) < contextTokens * threshold) return null;
+  const toSummarize = live.slice(0, live.length - keep);
+  const cursor = toSummarize.at(-1)?.id;
+  if (!cursor) return null;
+  return { toSummarize, keep: live.slice(live.length - keep), cursor };
+}

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

@@ -40,9 +40,14 @@ export function trimContext(messages, { maxTokens, keepLast = 8 } = {}) {
   if (estimateTokens(messages) <= maxTokens) return { messages, trimmed: 0, dropped: 0 };
 
   const out = messages.map((message) => ({ ...message }));
+  // Prefijo protegido: los system iniciales (base + objetivo + resumen de
+  // compactación). Nunca se recortan ni se descartan: son contexto esencial.
+  let head = 1;
+  while (head < out.length && out[head].role === 'system') head += 1;
+
   let trimmed = 0;
-  const cutoff = Math.max(1, out.length - keepLast);
-  for (let i = 1; i < cutoff; i++) {
+  const cutoff = Math.max(head, out.length - keepLast);
+  for (let i = head; i < cutoff; i++) {
     const message = out[i];
     if (message.role === 'tool' && typeof message.content === 'string' && message.content.length > TOOL_KEEP_CHARS) {
       out[i] = { ...message, content: `${message.content.slice(0, TOOL_KEEP_CHARS)}\n…[recortado por contexto]` };
@@ -52,15 +57,15 @@ export function trimContext(messages, { maxTokens, keepLast = 8 } = {}) {
   if (estimateTokens(out) <= maxTokens) return { messages: out, trimmed, dropped: 0 };
 
   let dropped = 0;
-  while (estimateTokens(out) > maxTokens && out.length > keepLast + 1) {
-    const first = out[1];
-    let end = 2;
+  while (estimateTokens(out) > maxTokens && out.length - head > keepLast) {
+    const first = out[head];
+    let end = head + 1;
     if (first.role === 'assistant' && Array.isArray(first.tool_calls)) {
       while (end < out.length && out[end].role === 'tool') end += 1;
     }
-    if (out.length - (end - 1) < keepLast) break;
-    out.splice(1, end - 1);
-    dropped += end - 1;
+    if (out.length - (end - head) < keepLast) break;
+    out.splice(head, end - head);
+    dropped += end - head;
   }
   return { messages: out, trimmed, dropped };
 }

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

@@ -57,14 +57,19 @@ export async function runAgent({
   maxRounds = MAX_TOOL_ROUNDS,
   maxTokens = 0,
   maxDurationMs = 0,
+  maxOutputTokens = 0,
+  promptCaching = false,
   repeatLimit = 3,
   wrapUp = true,
   stallWarnMs = 90000,
   retries = 2,
   retryDelayMs = 500,
   contextTokens = 0,
+  onLifecycle,
 }) {
   const working = [...messages];
+  const emitLifecycle = (type, payload) => onLifecycle?.({ type, ...payload });
+  emitLifecycle('run.start', { model });
   let usageTotal = null;
   const startedAt = Date.now();
   const fingerprints = new Map();
@@ -129,6 +134,8 @@ export async function runAgent({
             messages: contextMessages,
             tools,
             signal,
+            maxOutputTokens,
+            promptCaching,
             onEvent: (event) => {
               if (event && (event.type === 'reasoning' || event.type === 'tool_calls')) emitted = true;
               if (event?.type === 'text' && event.delta) emitted = true;
@@ -182,6 +189,7 @@ export async function runAgent({
             content: 'Cancelado por el usuario.',
           });
         }
+        emitLifecycle('run.end', { stopReason: 'aborted', usage: usageTotal });
         return {
           content: result.content ?? '',
           reasoning: result.reasoning ?? '',
@@ -208,11 +216,13 @@ export async function runAgent({
         output = NO_PROGRESS_MESSAGE;
       } else {
         newCalls++;
+        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);
@@ -244,7 +254,7 @@ export async function runAgent({
 
   let wrappedUp = false;
   if (wrapUp && (stopReason === 'max_rounds' || stopReason === 'no_progress' || stopReason === 'budget')) {
-    const wrap = await runFinalAnswer({ provider, config, model, working, signal, onEvent, maxRetries: retries, retryDelayMs });
+    const wrap = await runFinalAnswer({ provider, config, model, working, signal, onEvent, maxRetries: retries, retryDelayMs, maxOutputTokens, promptCaching });
     if (wrap.usage) accumulateUsage(wrap.usage);
     if (wrap.content) {
       working.push({ role: 'assistant', content: wrap.content, tokens_in: wrap.usage?.prompt_tokens, tokens_out: wrap.usage?.completion_tokens });
@@ -253,6 +263,7 @@ export async function runAgent({
     }
   }
 
+  emitLifecycle('run.end', { stopReason, usage: usageTotal });
   return {
     content,
     reasoning: '',
@@ -266,7 +277,7 @@ export async function runAgent({
 }
 
 /** Ronda final con tools deshabilitadas para forzar un cierre con texto. */
-async function runFinalAnswer({ provider, config, model, working, signal, onEvent, maxRetries, retryDelayMs }) {
+async function runFinalAnswer({ provider, config, model, working, signal, onEvent, maxRetries, retryDelayMs, maxOutputTokens, promptCaching }) {
   try {
     const result = await withRetry(
       () =>
@@ -275,6 +286,8 @@ async function runFinalAnswer({ provider, config, model, working, signal, onEven
           messages: [...working, { role: 'system', content: WRAP_UP_PROMPT }],
           tools: [],
           signal,
+          maxOutputTokens,
+          promptCaching,
           onEvent,
         }),
       { retries: maxRetries, baseDelayMs: retryDelayMs, signal }

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

@@ -0,0 +1,15 @@
+// Alcance estricto: cuando esta activo, el system prompt pide hacer exactamente
+// lo solicitado, sin mejoras, refactors ni cambios fuera del pedido.
+
+export const STRICT_SCOPE_PROMPT = [
+  'Modo estricto (solo lo pedido): hacé EXACTAMENTE lo que se te pide, nada más.',
+  '- No agregues mejoras, refactors, archivos, dependencias ni cambios que no se hayan pedido explícitamente.',
+  '- No amplíes el alcance: si el pedido menciona un archivo o una función, limitate a eso.',
+  '- Si para cumplir el pedido hiciera falta algo extra, preguntá antes de hacerlo.',
+  '- Preferí el cambio mínimo que resuelve el pedido y no toques código no relacionado.',
+].join('\n');
+
+/** Bloque de prompt del alcance estricto, o cadena vacía si está desactivado. */
+export function scopeDirective(enabled) {
+  return enabled ? STRICT_SCOPE_PROMPT : '';
+}

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

@@ -10,6 +10,10 @@ export const DEFAULT_CONFIG = {
   maxRounds: 0,
   maxTokens: 0,
   maxDurationMs: 0,
+  maxOutputTokens: 0,
+  promptCaching: false,
+  skills: { mode: 'lazy' },
+  compact: { enabled: true, threshold: 0.75, keepLast: 8 },
   tools: [],
   permissions: {},
   mcp: [],

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

@@ -12,10 +12,12 @@ export { resolveApiKey, resolveEnvMap } from './config/secrets.js';
 export { ensureUtf8Console } from './console.js';
 export { MAX_TOOL_ROUNDS, runAgent, parseToolArguments, normalizeToolOutput } from './agent/runAgent.js';
 export { estimateTokens, trimContext } from './agent/context.js';
+export { liveHistory, planCompaction, COMPACT_INSTRUCTION, SUMMARY_INSTRUCTION } from './agent/compact.js';
 export { diffLines, diffRows } from './tools/diff.js';
 export { isGitRepo, gitStatus, gitDiff } from './git/index.js';
 export { summarizeToolCall, previewToolResult } from './tools/labels.js';
 export { MODES, MODE_IDS, resolveMode } from './agent/modes.js';
+export { STRICT_SCOPE_PROMPT, scopeDirective } from './agent/scope.js';
 export { withRetry, isRetryableError, isAbortError } from './providers/resilience.js';
 export {
   PROVIDERS,
@@ -86,7 +88,14 @@ export { summarize } from './eval/report.js';
 export { runScorers, validateSchema, extractJson, SCORERS } from './eval/scorers.js';
 export { createJudge } from './eval/judge.js';
 export { createTaskWorkspace, normalizeExpect } from './eval/task.js';
-export { parseSkillMarkdown, loadSkills, mergeSkills, writeSkillFiles, buildSkillsPrompt } from './skills/index.js';
+export {
+  parseSkillMarkdown,
+  loadSkills,
+  mergeSkills,
+  writeSkillFiles,
+  buildSkillsPrompt,
+  buildSkillsIndex,
+} from './skills/index.js';
 export { parseSkillRef, fetchSkillFromGithub } from './skills/remote.js';
 export {
   searchMcpRegistry,

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'),