@danieltmn/tamnora 0.18.0 → 0.20.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.20.0] - 2026-10-14
+
+### Agregado
+
+- **Modo Voz** (`voice`): como Plan (solo lectura) pero con `write`/`edit`
+  **limitados a `.md` y `.json`**. La restricción por extensión se aplica en el
+  motor de tools (`writeExtensions`), aunque el permiso del usuario sea `allow`, y
+  se propaga a la consola, Telegram, subagentes, scheduler y la CLI/TUI.
+- **Manos libres** en la consola: loop conversacional
+  (escuchar → enviar → esperar la voz → volver a escuchar), con corte por silencio,
+  lectura forzada de la respuesta final y **auto-activación en modo Voz**.
+- **Asesor de un solo mensaje** (estilo Jarvis): el resumen breve y la
+  alerta/consejo viajan en un mismo texto, con **una** tarjeta y **una** locución.
+- **Tipo de agente por sesión**: cada sesión guarda su proveedor/modelo/modo y la
+  consola aplica y persiste ese tipo al abrirla.
+
+### Corregido
+
+- **Razonamiento y tokens con MiniMax/DeepSeek**: el pensamiento en línea
+  (`<think>`) y `reasoning_content` se separan del texto, y el streaming pide
+  `usage` (`stream_options`/`include_usage`) para que la consola muestre tokens y
+  contexto.
+- **Compactar** ya no pierde el historial previo al resumen.
+
+## [0.19.0] - 2026-10-12
+
+### Cambios
+
+- fix(consola): permiso y URL de preview legibles en movil
+- feat(voz): velocidad y tono como rangos numericos
+
 ## [0.18.0] - 2026-10-12
 
 ### Agregado

package/README.md

@@ -12,10 +12,12 @@ con TUI, consola web, tools locales, MCP y evaluacion de modelos.
   saca una captura PNG o lista los errores de consola) y `preview_url`.
 - **Voz**: el agente narra su progreso, puede **leer la respuesta final** (sin
   bloques de codigo ni tablas) y mandar audio bajo pedido (`speak`,
-  `/audioresumen`).
+  `/audioresumen`). El **modo Voz** habilita **manos libres**: hablás y responde en
+  audio, como una conversacion (y solo escribe notas `.md`/`.json`).
 - **Asesor**: una capa de comentario sobre el run que interpreta lo que hizo el
-  agente y, si aporta algo, avisa de un problema en el codigo, explica un proceso
-  o da un consejo (con tarjeta en el chat y voz opcional). No lee la respuesta.
+  agente y, en **un solo mensaje** estilo Jarvis, resume lo hecho y —si aporta—
+  avisa de un problema en el codigo, explica un proceso o da un consejo (tarjeta en
+  el chat y voz opcional). No lee la respuesta.
 - **Actualizar desde la consola**: la consola avisa cuando hay una version nueva
   y la instala con un click (el server se reinicia solo).
 - **Memoria y reglas**: memoria durable por proyecto (`memory`) y reglas por path
@@ -55,6 +57,7 @@ tamnora serve                 # consola web
 ```bash
 tamnora                   # TUI full-screen (REPL si no hay TTY)
 tamnora tui --mode plan   # modo plan: solo lectura, sin escritura ni bash
+tamnora tui --mode voice  # modo voz: solo lectura + notas .md/.json
 ```
 
 Atajos: `enter` enviar · `↑/↓` historial · `←/→` cursor · `home/end` inicio/fin ·

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

@@ -77,7 +77,7 @@ export async function tuiCommand(argv) {
     );
   const modeContext = (id) => {
     const m = resolveMode(id);
-    return { label: m.label, enabled: enabledFor(m), systemPrompt: promptFor(m) };
+    return { label: m.label, enabled: enabledFor(m), systemPrompt: promptFor(m), writeExtensions: m.writeExtensions };
   };
 
   const sessionId = store.createSession({ title: 'Consola', provider: providerId, model, cwd });
@@ -127,7 +127,7 @@ Consola full-screen (estilo opencode/codex). Atajos:
 Opciones:
   --provider <id>   Proveedor (por defecto: el activo)
   --model <id>      Modelo (por defecto: el activo)
-  --mode <id>       Modo de agente: agent | plan
+  --mode <id>       Modo de agente: agent | plan | voice
   --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

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

@@ -86,7 +86,8 @@ export function runTui({
       draw();
     });
 
-  const buildTools = () => createTools({ ...toolOptions, enabled: modeEnabled, onAsk });
+  const buildTools = () =>
+    createTools({ ...toolOptions, enabled: modeEnabled, writeExtensions: activeMode.writeExtensions, onAsk });
   let toolset = buildTools();
 
   function setMode(id) {

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

@@ -9,13 +9,18 @@ export const COMPACT_INSTRUCTION =
 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.';
 
+// Mensajes que existen para el usuario pero nunca entran al contexto del modelo:
+// el asesor (capa de comentario) y la marca de compactación (el resumen ya viaja
+// aparte como `meta.summary`).
+const NON_CONTEXT_NAMES = new Set(['advisor', 'compact']);
+
 /**
  * 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');
+  const filtered = history.filter((message) => !NON_CONTEXT_NAMES.has(message.name));
   if (!cursor) return filtered;
   const idx = filtered.findIndex((message) => message.id === cursor);
   return idx === -1 ? filtered : filtered.slice(idx + 1);

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

@@ -33,6 +33,35 @@ export const MODES = {
     systemPrompt:
       'Estás en modo PLAN: no modifiques archivos ni ejecutes comandos. Investigá el proyecto con las herramientas de solo lectura y respondé con un plan concreto y accionable.',
   },
+  voice: {
+    id: 'voice',
+    label: 'Voz',
+    description: 'Conversación por voz y notas: como Plan, pero solo crea/edita .md y .json.',
+    tools: [
+      'read',
+      'list',
+      'glob',
+      'grep',
+      'fetch_url',
+      'speak',
+      'screenshot',
+      'console_errors',
+      'preview_url',
+      'ask_user',
+      'offer_choices',
+      'show_plan',
+      'git_status',
+      'git_diff',
+      'git_log',
+      'write',
+      'edit',
+    ],
+    writeExtensions: ['.md', '.json'],
+    systemPrompt:
+      'Estás en modo VOZ: una conversación hablada con el usuario, breve y natural (tus respuestas se leen en voz alta). ' +
+      'No ejecutes comandos. Podés investigar el proyecto con las herramientas de solo lectura y SOLO podés crear o editar archivos .md y .json ' +
+      '(notas, ideas, listas, datos). Nunca toques otro tipo de archivo; si el usuario pide modificar código, decíselo y ofrecele hacerlo en modo Build.',
+  },
 };
 
 export const MODE_IDS = Object.keys(MODES);

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

@@ -23,24 +23,37 @@ export const openaiCompatibleProvider = {
   },
 
   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' });
+    const buildBody = () => {
+      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 body;
+    };
+    const run = (body) =>
+      requestStream({
+        url: joinUrl(baseUrl, '/chat/completions'),
+        headers: authHeaders({ apiKey, headers }),
+        providerLabel: 'OpenAI-compatible',
+        model,
+        body,
+        signal,
+        onEvent,
+      });
 
-    return requestStream({
-      url: joinUrl(baseUrl, '/chat/completions'),
-      headers: authHeaders({ apiKey, headers }),
-      providerLabel: 'OpenAI-compatible',
-      model,
-      body,
-      signal,
-      onEvent,
-    });
+    // La mayoria de los proveedores (OpenAI, MiniMax, DeepSeek, Groq...) solo
+    // reportan `usage` en streaming si se pide explicitamente.
+    try {
+      return await run({ ...buildBody(), stream_options: { include_usage: true } });
+    } catch (error) {
+      // Servidores OpenAI-compatibles que no conocen `stream_options`.
+      if (!/stream_options/i.test(error?.message ?? '')) throw error;
+      return run(buildBody());
+    }
   },
 };
 

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

@@ -89,6 +89,18 @@ export async function readOpenAISSE(response, { onEvent, signal } = {}) {
   const toolCalls = [];
   let serverError = null;
   let usage = null;
+  // Algunos modelos abren y cierran el stream antes de mandar `usage`; guardamos
+  // el ultimo que hayamos visto (puede llegar en un frame sin `choices`).
+  const think = createThinkSplitter({
+    onText(piece) {
+      content += piece;
+      onEvent?.({ type: 'text', delta: piece, full: content });
+    },
+    onReasoning(piece) {
+      reasoning += piece;
+      onEvent?.({ type: 'reasoning', delta: piece, full: reasoning });
+    },
+  });
 
   while (true) {
     const { done, value } = await readChunk(reader, signal);
@@ -114,14 +126,14 @@ export async function readOpenAISSE(response, { onEvent, signal } = {}) {
       const delta = parsed.choices?.[0]?.delta;
       if (!delta) continue;
 
-      if (delta.content) {
-        content += delta.content;
-        onEvent?.({ type: 'text', delta: delta.content, full: content });
-      }
-      if (delta.reasoning) {
-        reasoning += delta.reasoning;
-        onEvent?.({ type: 'reasoning', delta: delta.reasoning, full: reasoning });
+      // DeepSeek y MiniMax (con `reasoning_split`) mandan el pensamiento en
+      // `reasoning_content`; OpenRouter/OpenAI usan `reasoning`.
+      const reasoningDelta = delta.reasoning ?? delta.reasoning_content;
+      if (reasoningDelta) {
+        reasoning += reasoningDelta;
+        onEvent?.({ type: 'reasoning', delta: reasoningDelta, full: reasoning });
       }
+      if (delta.content) think.feed(delta.content);
       if (delta.tool_calls) {
         for (const tc of delta.tool_calls) {
           const idx = tc.index ?? 0;
@@ -142,9 +154,71 @@ export async function readOpenAISSE(response, { onEvent, signal } = {}) {
   }
 
   if (serverError) throw new Error(serverError);
+  think.flush();
   return finalize({ content, reasoning, toolCalls, usage });
 }
 
+const THINK_OPEN = '<think>';
+const THINK_CLOSE = '</think>';
+
+/**
+ * MiniMax (sin `reasoning_split`) y otros modelos sin un campo de razonamiento
+ * mandan el pensamiento dentro del propio `content`, envuelto en
+ * `<think>…</think>`. Este separador incremental lo mueve a `reasoning`,
+ * tolerando que la etiqueta venga partida entre fragmentos del stream.
+ */
+function createThinkSplitter({ onText, onReasoning }) {
+  let mode = 'start';
+  let pending = '';
+  const emitText = (text) => text && onText(text);
+  const emitReasoning = (text) => text && onReasoning(text);
+
+  return {
+    feed(chunk) {
+      if (!chunk) return;
+      pending += chunk;
+      for (;;) {
+        if (mode === 'content') {
+          emitText(pending);
+          pending = '';
+          return;
+        }
+        if (mode === 'start') {
+          if (pending.startsWith(THINK_OPEN)) {
+            pending = pending.slice(THINK_OPEN.length);
+            mode = 'thinking';
+            continue;
+          }
+          // Mientras sea un prefijo de la etiqueta, puede ser el inicio: esperar.
+          if (THINK_OPEN.startsWith(pending)) return;
+          mode = 'content';
+          continue;
+        }
+        const idx = pending.indexOf(THINK_CLOSE);
+        if (idx !== -1) {
+          emitReasoning(pending.slice(0, idx));
+          pending = pending.slice(idx + THINK_CLOSE.length);
+          mode = 'content';
+          continue;
+        }
+        // Conservamos el posible cierre partido al final.
+        const keep = THINK_CLOSE.length - 1;
+        if (pending.length > keep) {
+          emitReasoning(pending.slice(0, pending.length - keep));
+          pending = pending.slice(-keep);
+        }
+        return;
+      }
+    },
+    flush() {
+      if (!pending) return;
+      if (mode === 'thinking') emitReasoning(pending);
+      else emitText(pending);
+      pending = '';
+    },
+  };
+}
+
 /**
  * Parse Ollama's native NDJSON stream (`/api/chat`).
  * @returns {Promise<{content:string, reasoning:string, toolCalls:object[], usage:object|null}>}

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

@@ -422,11 +422,11 @@ const MAX_SPEAK_TEXT = 1200;
  * son del cliente (la consola lo reproduce y Telegram lo manda como nota de
  * voz), asi que aca solo se normaliza el pedido y se acota el largo.
  */
-export function speakTool(_root, { texto, voice, rate } = {}) {
+export function speakTool(_root, { texto, voice, rate, pitch } = {}) {
   const value = String(texto ?? '').replace(/\s+/g, ' ').trim();
   if (!value) return 'Error: falta "texto".';
   const recortado = value.length > MAX_SPEAK_TEXT ? `${value.slice(0, MAX_SPEAK_TEXT - 1).trimEnd()}…` : value;
-  const opciones = [voice, rate].filter(Boolean).join(', ');
+  const opciones = [voice, rate, pitch].filter(Boolean).join(', ');
   return `Audio pedido${opciones ? ` (${opciones})` : ''}: "${recortado}". El cliente lo reproduce o lo envía como nota de voz.`;
 }
 

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

@@ -1,7 +1,15 @@
+import path from 'node:path';
 import { TOOL_DEFINITIONS, TOOL_NAMES } from './schema.js';
 import { EXECUTORS } from './executors.js';
 import { evaluatePermission } from './permissions.js';
 
+const WRITE_TOOLS = new Set(['write', 'edit']);
+
+/** Extension (en minusculas) de un path, o '' si no tiene. */
+function extensionOf(p) {
+  return path.extname(String(p ?? '')).toLowerCase();
+}
+
 /**
  * Build the local tool registry.
  *
@@ -9,16 +17,25 @@ import { evaluatePermission } from './permissions.js';
  * @param {string} opts.root - workspace root (all paths are confined here)
  * @param {string[]} [opts.enabled] - tool names to expose (default: all)
  * @param {object} [opts.permissions] - policy per tool ('allow'|'ask'|'deny' or pattern map)
+ * @param {string[]} [opts.writeExtensions] - si se define, `write`/`edit` solo aceptan estas extensiones (p.ej. ['.md', '.json'])
  * @param {(name:string, args:object)=>Promise<boolean>} [opts.onAsk] - interactive approval
  * @param {(payload:{title:string, questions:object[]})=>Promise<{answers:object,cancelled?:boolean}>} [opts.onQuestion] - interactive form
  * @param {boolean} [opts.yes] - auto-approve 'ask' (non-interactive)
  * @param {AbortSignal} [opts.signal] - cancela las tools de larga duracion (bash, git)
  */
-export function createToolRegistry({ root, enabled, permissions = {}, onAsk, onQuestion, yes = false, signal } = {}) {
+export function createToolRegistry({ root, enabled, permissions = {}, onAsk, onQuestion, yes = false, signal, writeExtensions } = {}) {
   const names = new Set(enabled?.length ? enabled : TOOL_NAMES);
   const definitions = TOOL_DEFINITIONS.filter((d) => names.has(d.function.name));
+  const allowedWrite = Array.isArray(writeExtensions) && writeExtensions.length
+    ? new Set(writeExtensions.map((ext) => String(ext).toLowerCase()))
+    : null;
+
+  // Restriccion por extension (modo Voz): solo write/edit, y solo si el modo la define.
+  const writeAllowed = (name, args = {}) =>
+    !allowedWrite || !WRITE_TOOLS.has(name) || allowedWrite.has(extensionOf(args?.path));
 
   async function authorize(name, args = {}) {
+    if (!writeAllowed(name, args)) return 'deny';
     let decision = evaluatePermission(name, args, permissions);
     if (decision === 'ask') {
       if (onAsk) decision = (await onAsk(name, args)) ? 'allow' : 'deny';
@@ -31,6 +48,9 @@ export function createToolRegistry({ root, enabled, permissions = {}, onAsk, onQ
     if (!names.has(name) || !(name in EXECUTORS)) {
       return `Error: herramienta desconocida "${name}".`;
     }
+    if (!writeAllowed(name, args)) {
+      return `Error: en este modo solo se permite crear o editar ${[...allowedWrite].join(' / ')}.`;
+    }
 
     const decision = await authorize(name, args);
     if (decision === 'deny') {

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

@@ -145,6 +145,7 @@ export const TOOL_DEFINITIONS = [
           texto: { type: 'string', description: 'Text to speak (long text is trimmed)' },
           voice: { type: 'string', description: 'Optional voice id, e.g. "es-AR-ElenaNeural"' },
           rate: { type: 'string', description: 'Optional speed, e.g. "+10%"' },
+          pitch: { type: 'string', description: 'Optional tone, e.g. "-10Hz"' },
         },
         required: ['texto'],
       },

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

@@ -2,15 +2,17 @@ import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { liveHistory, planCompaction } from '../src/agent/compact.js';
 
-test('liveHistory saca al asesor y recorta hasta el cursor', () => {
+test('liveHistory saca al asesor y la marca de compactación, y recorta hasta el cursor', () => {
   const history = [
     { id: 'a', role: 'user', content: '1' },
     { id: 'b', role: 'assistant', name: 'advisor', content: 'charla' },
     { id: 'c', role: 'assistant', content: '2' },
     { id: 'd', role: 'user', content: '3' },
     { id: 'e', role: 'assistant', name: 'advisor', mode: 'summary', content: 'resumen de lo hecho' },
+    { id: 'f', role: 'assistant', name: 'compact', mode: 'compact', content: 'resumen de contexto' },
   ];
-  // El consejo y el resumen del asesor nunca entran al contexto del modelo.
+  // El consejo, el resumen del asesor y la marca de compactación nunca entran
+  // al contexto del modelo.
   assert.deepEqual(liveHistory(history).map((m) => m.id), ['a', 'c', 'd']);
   assert.deepEqual(liveHistory(history, 'a').map((m) => m.id), ['c', 'd']);
   // Cursor inexistente: no perdemos contexto, devolvemos todo (sin asesor).

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

@@ -132,6 +132,35 @@ test('openaiCompatible manda max_tokens y respeta maxTokensField', async () => {
   assert.equal(bodies[2].max_tokens, undefined);
 });
 
+test('openaiCompatible pide usage en streaming y cae si el server no lo soporta', async () => {
+  const bodies = [];
+  const original = globalThis.fetch;
+  const sse = 'data: {"choices":[{"delta":{"content":"hi"}}]}\n\ndata: [DONE]\n\n';
+  globalThis.fetch = async (_url, init) => {
+    const body = JSON.parse(init.body);
+    bodies.push(body);
+    if (body.stream_options) {
+      return new Response(
+        JSON.stringify({ error: { message: 'Unrecognized request argument supplied: stream_options' } }),
+        { status: 400, headers: { 'content-type': 'application/json' } }
+      );
+    }
+    return new Response(sse, { status: 200, headers: { 'content-type': 'text/event-stream' } });
+  };
+  const cfg = { baseUrl: 'https://x/v1', apiKey: 'k' };
+  try {
+    const res = await openaiCompatibleProvider.streamChat(cfg, {
+      model: 'm',
+      messages: [{ role: 'user', content: 'u' }],
+    });
+    assert.equal(res.content, 'hi');
+  } finally {
+    globalThis.fetch = original;
+  }
+  assert.deepEqual(bodies[0].stream_options, { include_usage: true });
+  assert.equal(bodies[1].stream_options, undefined);
+});
+
 test('applyPromptCache: anthropic marca el system, openai agrega la clave', () => {
   const anthropic = { messages: [{ role: 'system', content: 'sys' }, { role: 'user', content: 'u' }] };
   applyPromptCache(anthropic, { mode: 'anthropic' });

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

@@ -21,6 +21,52 @@ test('readOpenAISSE parses content, reasoning and tool calls', async () => {
   assert.equal(res.toolCalls[0].function.arguments, '{"a":1}');
 });
 
+test('readOpenAISSE separa el pensamiento en línea (<think>) del contenido', async () => {
+  const sse = [
+    'data: {"choices":[{"delta":{"content":"<thi"}}]}',
+    'data: {"choices":[{"delta":{"content":"nk>pienso"}}]}',
+    'data: {"choices":[{"delta":{"content":" mucho</thi"}}]}',
+    'data: {"choices":[{"delta":{"content":"nk>Hola"}}]}',
+    'data: [DONE]',
+    '',
+  ].join('\n');
+
+  const events = [];
+  const res = await readOpenAISSE(new Response(sse), { onEvent: (event) => events.push(event) });
+  assert.equal(res.reasoning, 'pienso mucho');
+  assert.equal(res.content, 'Hola');
+  assert.ok(events.some((event) => event.type === 'reasoning' && event.full.includes('pienso')));
+  assert.ok(events.some((event) => event.type === 'text' && event.full === 'Hola'));
+});
+
+test('readOpenAISSE parsea reasoning_content (DeepSeek/MiniMax)', async () => {
+  const sse = [
+    'data: {"choices":[{"delta":{"reasoning_content":"pienso "}}]}',
+    'data: {"choices":[{"delta":{"reasoning_content":"esto"}}]}',
+    'data: {"choices":[{"delta":{"content":"Hola"}}]}',
+    'data: {"choices":[],"usage":{"prompt_tokens":5,"completion_tokens":2,"total_tokens":7}}',
+    'data: [DONE]',
+    '',
+  ].join('\n');
+
+  const res = await readOpenAISSE(new Response(sse));
+  assert.equal(res.reasoning, 'pienso esto');
+  assert.equal(res.content, 'Hola');
+  assert.deepEqual(res.usage, { prompt_tokens: 5, completion_tokens: 2, total_tokens: 7 });
+});
+
+test('readOpenAISSE no toca el contenido sin etiquetas <think>', async () => {
+  const sse = [
+    'data: {"choices":[{"delta":{"content":"<p>hola</p>"}}]}',
+    'data: {"choices":[{"delta":{"content":" mundo"}}]}',
+    'data: [DONE]',
+    '',
+  ].join('\n');
+  const res = await readOpenAISSE(new Response(sse));
+  assert.equal(res.content, '<p>hola</p> mundo');
+  assert.equal(res.reasoning, '');
+});
+
 test('readNDJSON parses Ollama messages and tool calls', async () => {
   const ndjson = [
     '{"message":{"content":"Hola "},"done":false}',

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

@@ -91,6 +91,36 @@ test('edit refuses ambiguous replacements without replaceAll', async () => {
   );
 });
 
+test('writeExtensions limita write/edit por extension', async () => {
+  const root = await makeWorkspace();
+  const reg = createToolRegistry({
+    root,
+    permissions: { write: 'allow', edit: 'allow' },
+    writeExtensions: ['.md', '.json'],
+  });
+
+  assert.match(await reg.execute('write', { path: 'nota.md', content: '# hola' }), /Creado|Escrito/);
+  assert.match(await reg.execute('write', { path: 'datos.json', content: '{}' }), /Creado|Escrito/);
+  assert.match(await reg.execute('write', { path: 'src/x.txt', content: 'nope' }), /solo se permite crear o editar/);
+  assert.match(await reg.execute('write', { path: 'sin_extension', content: 'nope' }), /solo se permite crear o editar/);
+
+  assert.match(
+    await reg.execute('edit', { path: 'datos.json', oldString: '{}', newString: '{"a":1}' }),
+    /Editado/
+  );
+  assert.match(
+    await reg.execute('edit', { path: 'nota.txt', oldString: 'x', newString: 'y' }),
+    /solo se permite crear o editar/
+  );
+
+  // Leer sigue permitido aunque la extension no este en la lista.
+  assert.match(await reg.execute('read', { path: 'src/a.js' }), /const a = 1;/);
+
+  // Sin writeExtensions no hay restriccion (modo agent intacto).
+  const open = createToolRegistry({ root, permissions: { write: 'allow' } });
+  assert.match(await open.execute('write', { path: 'src/libre.txt', content: 'ok' }), /Creado|Escrito/);
+});
+
 test('permission "ask" is denied by default and allowed with yes', async () => {
   const root = await makeWorkspace();
   const denied = createToolRegistry({ root });