@danieltmn/tamnora 0.6.2 → 0.7.0

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

@@ -0,0 +1,104 @@
+// Redaccion de secretos para no filtrarlos a la conversacion (y de ahi al
+// historial, a la UI o a un canal de mensajeria). Es defensa en profundidad:
+// la barrera principal es no inyectar secretos en el entorno de los MCP.
+
+import { getEnv } from './env.js';
+
+/** Un nombre de variable "sensible" (token, password, key, credencial...). */
+const SECRET_NAME = /(TOKEN|SECRET|PASSWORD|PASSWD|API[_-]?KEY|ACCESS[_-]?KEY|PRIVATE[_-]?KEY|CREDENTIAL|AUTH|COOKIE|SESSION)/i;
+
+/** Patrones de tokens conocidos, utiles aunque no vengan de una variable. */
+const SECRET_PATTERNS = [
+  /npm_[A-Za-z0-9]{16,}/g,
+  /sk-[A-Za-z0-9_-]{16,}/g,
+  /ghp_[A-Za-z0-9]{20,}/g,
+  /github_pat_[A-Za-z0-9_]{20,}/g,
+  /AKIA[0-9A-Z]{16}/g,
+  /AIza[0-9A-Za-z_-]{30,}/g,
+  /xox[baprs]-[A-Za-z0-9-]{10,}/g,
+  /ya29\.[A-Za-z0-9_-]{20,}/g,
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+];
+
+export const REDACTED = '[REDACTADO]';
+
+/** ¿El nombre de la variable parece contener un secreto? */
+export function isSecretName(name) {
+  return SECRET_NAME.test(String(name ?? ''));
+}
+
+/**
+ * Valores de entorno que hay que redactar: los de variables con nombre
+ * sensible y al menos 8 caracteres (evita tapar valores triviales).
+ * @param {Record<string,string>} [env]
+ * @returns {string[]} ordenados de mayor a menor (los mas largos primero)
+ */
+export function secretValues(env = getEnv()) {
+  const values = new Set();
+  for (const [name, value] of Object.entries(env ?? {})) {
+    if (!isSecretName(name)) continue;
+    const text = String(value ?? '');
+    if (text.length >= 8) values.add(text);
+  }
+  return [...values].sort((a, b) => b.length - a.length);
+}
+
+/**
+ * Redacta secretos conocidos (valores de env sensibles + patrones de tokens).
+ * @param {string} text
+ * @param {{env?:Record<string,string>, extra?:string[]}} [opts]
+ * @returns {string}
+ */
+export function redactSecrets(text, { env, extra = [] } = {}) {
+  let output = String(text ?? '');
+  if (!output) return output;
+
+  const values = [...secretValues(env), ...extra].filter((v) => v && v.length >= 8);
+  for (const value of values) {
+    if (output.includes(value)) output = output.split(value).join(REDACTED);
+  }
+  for (const pattern of SECRET_PATTERNS) {
+    output = output.replace(pattern, REDACTED);
+  }
+  return output;
+}
+
+/**
+ * Redacta recursivamente strings y valores bajo claves sensibles en un objeto.
+ * @param {unknown} value
+ * @param {{env?:Record<string,string>, extra?:string[]}} [opts]
+ */
+export function redactDeep(value, opts = {}) {
+  if (typeof value === 'string') return redactSecrets(value, opts);
+  if (Array.isArray(value)) return value.map((item) => redactDeep(item, opts));
+  if (value && typeof value === 'object') {
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+      result[key] = isSecretName(key) ? REDACTED : redactDeep(item, opts);
+    }
+    return result;
+  }
+  return value;
+}
+
+/**
+ * Enmascara un valor para mostrarlo al cliente (nunca el secreto completo).
+ * `env:VAR` se conserva para que se vea la indireccion.
+ */
+export function maskSecret(value) {
+  const text = String(value ?? '');
+  if (!text) return '';
+  if (text.startsWith('env:')) return text;
+  if (text.length <= 4) return '••••';
+  return `••••${text.slice(-4)}`;
+}
+
+/** Enmascara un mapa de env para devolverlo por la API. */
+export function maskEnv(env) {
+  if (!env || typeof env !== 'object') return env ?? null;
+  const result = {};
+  for (const [key, value] of Object.entries(env)) {
+    result[key] = isSecretName(key) ? maskSecret(value) : String(value ?? '');
+  }
+  return result;
+}

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

@@ -235,3 +235,96 @@ test('agent aggregates usage and stamps tokens on assistant messages', async ()
   assert.equal(assistants[1].tokens_in, 20);
   assert.equal(assistants[1].tokens_out, 5);
 });
+
+test('agent sigue solo hasta end_turn sin tope de rondas', async () => {
+  let round = 0;
+  const provider = {
+    async streamChat(_config, { tools }) {
+      if (!tools || tools.length === 0) return { content: 'listo', reasoning: '', toolCalls: [] };
+      round += 1;
+      if (round <= 10) {
+        return {
+          content: '',
+          reasoning: '',
+          toolCalls: [{ id: `c${round}`, function: { name: 'step', arguments: JSON.stringify({ n: round }) } }],
+        };
+      }
+      return { content: 'terminado', reasoning: '', toolCalls: [] };
+    },
+  };
+
+  const result = await runAgent({
+    provider,
+    config: {},
+    model: 'm',
+    messages: [{ role: 'user', content: 'x' }],
+    tools: [{ type: 'function', function: { name: 'step', parameters: {} } }],
+    execute: async () => 'ok',
+  });
+
+  assert.equal(result.stopReason, 'end_turn');
+  assert.equal(result.rounds, 11);
+  assert.equal(result.content, 'terminado');
+});
+
+test('agent corta por no progreso y cierra con resumen sin tools', async () => {
+  const provider = {
+    async streamChat(_config, { tools }) {
+      if (!tools || tools.length === 0) return { content: 'resumen final', reasoning: '', toolCalls: [] };
+      return {
+        content: '',
+        reasoning: '',
+        toolCalls: [{ id: 'x', function: { name: 'noop', arguments: '{}' } }],
+      };
+    },
+  };
+  let executions = 0;
+  const result = await runAgent({
+    provider,
+    config: {},
+    model: 'm',
+    messages: [{ role: 'user', content: 'x' }],
+    tools: [{ type: 'function', function: { name: 'noop', parameters: {} } }],
+    execute: async () => {
+      executions += 1;
+      return 'ok';
+    },
+    repeatLimit: 2,
+  });
+
+  assert.equal(result.stopReason, 'no_progress');
+  assert.equal(result.wrappedUp, true);
+  assert.equal(result.content, 'resumen final');
+  assert.equal(executions, 2);
+});
+
+test('agent respeta el presupuesto de tokens y cierra con resumen', async () => {
+  let round = 0;
+  const provider = {
+    async streamChat(_config, { tools }) {
+      if (!tools || tools.length === 0) {
+        return { content: 'cierre', reasoning: '', toolCalls: [], usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 } };
+      }
+      round += 1;
+      return {
+        content: '',
+        reasoning: '',
+        toolCalls: [{ id: `c${round}`, function: { name: 'step', arguments: JSON.stringify({ n: round }) } }],
+        usage: { prompt_tokens: 10, completion_tokens: 10, total_tokens: 20 },
+      };
+    },
+  };
+
+  const result = await runAgent({
+    provider,
+    config: {},
+    model: 'm',
+    messages: [{ role: 'user', content: 'x' }],
+    tools: [{ type: 'function', function: { name: 'step', parameters: {} } }],
+    execute: async () => 'ok',
+    maxTokens: 50,
+  });
+
+  assert.equal(result.stopReason, 'budget');
+  assert.equal(result.content, 'cierre');
+});

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

@@ -6,7 +6,9 @@ import { tmpdir } from 'node:os';
 import path from 'node:path';
 import {
   buildMcpRegistry,
+  childEnv,
   connectMcpStdioServer,
+  mcpResultToText,
   mcpTransport,
 } from '../src/index.js';
 
@@ -156,3 +158,68 @@ test('buildMcpRegistry connects over HTTP (JSON responses)', async () => {
     server.close();
   }
 });
+
+const ENV_SERVER = `
+import readline from 'node:readline';
+readline.createInterface({ input: process.stdin }).on('line', (line) => {
+  if (!line.trim()) return;
+  const m = JSON.parse(line);
+  let r = null;
+  if (m.method === 'initialize') r = { jsonrpc: '2.0', id: m.id, result: { protocolVersion: '2025-06-18', capabilities: { tools: {} } } };
+  else if (m.method === 'tools/list') r = { jsonrpc: '2.0', id: m.id, result: { tools: [{ name: 'env', inputSchema: { type: 'object' } }] } };
+  else if (m.method === 'tools/call') r = { jsonrpc: '2.0', id: m.id, result: { content: [{ type: 'text', text: String(process.env.TAMNORA_TEST_VALUE ?? '') }] } };
+  if (r) process.stdout.write(JSON.stringify(r) + '\\n');
+});
+`;
+
+async function makeEnvServer() {
+  const dir = await mkdtemp(path.join(tmpdir(), 'tamnora-mcp-env-'));
+  const file = path.join(dir, 'env-server.mjs');
+  await writeFile(file, ENV_SERVER);
+  return { id: 'env', command: process.execPath, args: [file] };
+}
+
+test('childEnv no hereda process.env por defecto y resuelve env:VAR', () => {
+  process.env.TAMNORA_TEST_VALUE = 'visible123';
+  try {
+    assert.equal(childEnv({}).TAMNORA_TEST_VALUE, undefined);
+    const declared = childEnv({ env: { VAL: 'env:TAMNORA_TEST_VALUE' } });
+    assert.equal(declared.VAL, 'visible123');
+    assert.equal(childEnv({ inheritEnv: true }).TAMNORA_TEST_VALUE, 'visible123');
+  } finally {
+    delete process.env.TAMNORA_TEST_VALUE;
+  }
+});
+
+test('un MCP stdio no ve el entorno del padre salvo inheritEnv o env declarado', async () => {
+  process.env.TAMNORA_TEST_VALUE = 'visible123';
+  try {
+    const hidden = await connectMcpStdioServer(await makeEnvServer());
+    assert.equal(await hidden.callTool('env', {}), '');
+    hidden.close();
+
+    const declared = await connectMcpStdioServer({
+      ...(await makeEnvServer()),
+      env: { TAMNORA_TEST_VALUE: 'env:TAMNORA_TEST_VALUE' },
+    });
+    assert.equal(await declared.callTool('env', {}), 'visible123');
+    declared.close();
+
+    const inherited = await connectMcpStdioServer({ ...(await makeEnvServer()), inheritEnv: true });
+    assert.equal(await inherited.callTool('env', {}), 'visible123');
+    inherited.close();
+  } finally {
+    delete process.env.TAMNORA_TEST_VALUE;
+  }
+});
+
+test('mcpResultToText redacta secretos del entorno', () => {
+  process.env.TAMNORA_TEST_SECRET = 'ultrasecreto123';
+  try {
+    const text = mcpResultToText({ content: [{ type: 'text', text: 'valor=ultrasecreto123 fin' }] });
+    assert.match(text, /REDACTADO/);
+    assert.doesNotMatch(text, /ultrasecreto123/);
+  } finally {
+    delete process.env.TAMNORA_TEST_SECRET;
+  }
+});

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

@@ -0,0 +1,45 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  REDACTED,
+  isSecretName,
+  maskEnv,
+  maskSecret,
+  redactDeep,
+  redactSecrets,
+  secretValues,
+} from '../src/redact.js';
+
+test('isSecretName detecta nombres sensibles', () => {
+  assert.equal(isSecretName('NPM_TOKEN'), true);
+  assert.equal(isSecretName('MYSQL_PASSWORD'), true);
+  assert.equal(isSecretName('OPENAI_API_KEY'), true);
+  assert.equal(isSecretName('PATH'), false);
+  assert.equal(isSecretName('USERNAME'), false);
+});
+
+test('secretValues toma valores de nombres sensibles (>= 8 chars)', () => {
+  const values = secretValues({ NPM_TOKEN: 'npm_abcdefgh', PATH: '/usr/bin', SHORT: 'x' });
+  assert.deepEqual(values, ['npm_abcdefgh']);
+});
+
+test('redactSecrets tapa valores de env y patrones conocidos', () => {
+  const env = { NPM_TOKEN: 'npm_secretvalue123456' };
+  assert.equal(redactSecrets('token= npm_secretvalue123456', { env }), `token= ${REDACTED}`);
+  assert.equal(redactSecrets('ghp_abcdefghijklmnopqrst'), REDACTED);
+  assert.equal(redactSecrets('hola mundo'), 'hola mundo');
+});
+
+test('redactDeep tapa claves sensibles dentro de objetos', () => {
+  const result = redactDeep({ user: 'ana', password: 'hunter2', nested: { apiKey: 'abc123' } });
+  assert.deepEqual(result, { user: 'ana', password: REDACTED, nested: { apiKey: REDACTED } });
+});
+
+test('maskSecret y maskEnv enmascaran sin exponer el valor', () => {
+  assert.equal(maskSecret('supersecret'), '••••cret');
+  assert.equal(maskSecret('env:NPM_TOKEN'), 'env:NPM_TOKEN');
+  assert.deepEqual(maskEnv({ MYSQL_HOST: 'db.local', MYSQL_PASSWORD: 'supersecret' }), {
+    MYSQL_HOST: 'db.local',
+    MYSQL_PASSWORD: '••••cret',
+  });
+});

package/harness/packages/server/public/app.js

@@ -178,7 +178,7 @@ function activateTab(name) {
   hideMoreMenu();
   if (name === 'runs') refreshRuns();
   if (name === 'providers') refreshProviders();
-  if (name === 'ajustes') { refreshMcp(); refreshSkills(); refreshChannels(); }
+  if (name === 'ajustes') { refreshMcp(); refreshSkills(); refreshChannels(); refreshLimits(); }
 }
 
 document.querySelectorAll('.tab[data-tab]').forEach((t) =>
@@ -203,27 +203,61 @@ document.addEventListener('keydown', (event) => {
 /* --- settings modal (modo / proveedor / modelo / auto) -------------------- */
 
 const settingsModal = $('#settings-modal');
+const agentControls = $('#agent-settings-controls');
+const agentControlsSlot = $('#agent-controls-slot');
+const settingsControlsSlot = $('#settings-controls-slot');
+
+/** Los controles modo/proveedor/modelo/auto se comparten entre el tab Agente
+ *  y el modal: se mueven de un slot al otro para no duplicar IDs ni estado. */
+function moveAgentControls(target) {
+  if (agentControls && target) target.appendChild(agentControls);
+}
+
+function openSettingsModal() {
+  if (!settingsModal) return;
+  moveAgentControls(settingsControlsSlot);
+  syncDefaultCwd();
+  settingsModal.showModal();
+}
+
+function closeSettingsModal() {
+  moveAgentControls(agentControlsSlot);
+  settingsModal?.close();
+}
+
 if (settingsModal) {
-  $('#settings-toggle')?.addEventListener('click', () => {
-    syncDefaultCwd();
-    settingsModal.showModal();
-  });
-  $('#settings-close')?.addEventListener('click', () => settingsModal.close());
-  $('#settings-done')?.addEventListener('click', () => settingsModal.close());
+  $('#settings-toggle')?.addEventListener('click', openSettingsModal);
+  $('#settings-close')?.addEventListener('click', closeSettingsModal);
+  $('#settings-done')?.addEventListener('click', closeSettingsModal);
   $('#settings-providers')?.addEventListener('click', () => {
-    settingsModal.close();
+    closeSettingsModal();
     activateTab('providers');
   });
-  $('#default-cwd-pick')?.addEventListener('click', () => {
-    settingsModal.close();
-    openFolderPicker('default');
-  });
+  $('#agent-settings-open')?.addEventListener('click', openSettingsModal);
+  $('#agent-providers')?.addEventListener('click', () => activateTab('providers'));
+  $('#default-cwd-pick')?.addEventListener('click', () => openFolderPicker('default'));
   $('#default-cwd-clear')?.addEventListener('click', () => {
     writeDefaultCwd('');
     syncDefaultCwd();
   });
   settingsModal.addEventListener('click', (event) => {
-    if (event.target === settingsModal) settingsModal.close();
+    if (event.target === settingsModal) closeSettingsModal();
+  });
+  settingsModal.addEventListener('close', () => moveAgentControls(agentControlsSlot));
+}
+
+// El footer (modo · proveedor · modelo · estado) abre el modal de ajustes.
+const statusbarEl = $('#statusbar');
+if (statusbarEl) {
+  statusbarEl.addEventListener('click', (event) => {
+    if (event.target.closest('#sb-context')) return;
+    openSettingsModal();
+  });
+  statusbarEl.addEventListener('keydown', (event) => {
+    if (event.key === 'Enter' || event.key === ' ') {
+      event.preventDefault();
+      openSettingsModal();
+    }
   });
 }
 
@@ -235,7 +269,7 @@ const PALETTE_COMMANDS = [
   { id: 'compact', label: 'Compactar la conversación', hint: '/compact', run: () => runSlash('compact') },
   { id: 'clear', label: 'Limpiar la conversación', hint: '/clear', run: () => runSlash('clear') },
   { id: 'mode', label: 'Cambiar Plan / Build', hint: 'Ctrl+.', run: () => toggleMode() },
-  { id: 'settings', label: 'Ajustes del agente (modelo, modo, auto)', run: () => { syncDefaultCwd(); settingsModal?.showModal(); } },
+  { id: 'settings', label: 'Ajustes del agente (modelo, modo, auto)', run: () => openSettingsModal() },
   { id: 'providers', label: 'Gestionar proveedores', run: () => activateTab('providers') },
   { id: 'ajustes', label: 'MCP y Skills (ajustes)', run: () => activateTab('ajustes') },
   { id: 'explorer', label: 'Mostrar u ocultar archivos', run: () => setExplorerOpen(!state.explorerOpen) },
@@ -1545,11 +1579,25 @@ function renderCompletion(message, data) {
   const duration = formatDuration(data.durationMs);
   if (duration) parts.push(duration);
   if (data.tokens?.total_tokens) parts.push(`${Number(data.tokens.total_tokens).toLocaleString('es')} tokens`);
-  const maxed = data.stopReason === 'max_rounds';
-  message.tools.appendChild(el('div', maxed ? 'chip warn' : 'chip ok', `${maxed ? '⚠ máximo de rondas' : '✓ terminado'} · ${parts.join(' · ')}`));
+  const cut = ['max_rounds', 'no_progress', 'budget'].includes(data.stopReason);
+  const label = cut ? (data.wrappedUp ? '⚠ corte de seguridad · resumen' : '⚠ corte de seguridad') : '✓ terminado';
+  message.tools.appendChild(el('div', cut ? 'chip warn' : 'chip ok', `${label} · ${parts.join(' · ')}`));
   scrollMessages(paneOf(message));
 }
 
+/** Retoma un turno cortado por límite/bucle sin tener que escribir "continúa". */
+function addContinueButton(turn, data) {
+  const btn = el('button', 'chip', data.wrappedUp ? '↻ Continuar el trabajo' : '↻ Continuar');
+  btn.type = 'button';
+  btn.addEventListener('click', () => {
+    if (state.panes.get(turn.sessionKey)?.working) return;
+    chatInput.value = 'Continuá donde quedaste.';
+    sendMessage();
+  });
+  turn.assistant().tools.appendChild(btn);
+  scrollMessages(paneOf(turn.assistant()));
+}
+
 function handleChatEvent(event, data, turn) {
   if (handleAgentEvent(event, data, turn)) return;
   if (event === 'agent_start') {
@@ -1615,6 +1663,8 @@ function handleChatEvent(event, data, turn) {
     if (!turn.sawText) setText(turn.assistant(), `↻ reintentando (${data.attempt}) en ${Math.round((data.delayMs || 0) / 1000)} s...`);
   } else if (event === 'trim') {
     turn.assistant().tools.appendChild(el('div', 'chip', `✂ contexto recortado (${data.trimmed} resultados, ${data.dropped} mensajes)`));
+  } else if (event === 'repeat') {
+    turn.assistant().tools.appendChild(el('div', 'chip warn', `↻ ${data.name} repetida sin cambios`));
   } else if (event === 'warning') {
     turn.assistant().tools.appendChild(el('div', 'chip', `⚠ ${data.message}`));
   } else if (event === 'error') {
@@ -1625,12 +1675,16 @@ function handleChatEvent(event, data, turn) {
     const finalText = (turn.active?.textEl?.textContent ?? '').trim();
     const tools = Number(data.toolCalls) || 0;
     if (!finalText) {
-      if (data.stopReason === 'max_rounds') {
+      if (data.stopReason === 'no_progress') {
+        setText(turn.assistant(), '⚠ El agente se quedó repitiendo las mismas herramientas sin avanzar.');
+      } else if (data.stopReason === 'budget') {
+        setText(turn.assistant(), '⚠ El agente alcanzó el presupuesto de tokens/tiempo sin respuesta final.');
+      } else if (data.stopReason === 'max_rounds') {
         setText(
           turn.assistant(),
           `⚠ El agente alcanzó el máximo de rondas (${data.rounds ?? '?'}) sin dejar una respuesta final.${
             tools ? ` Hizo ${tools} llamadas a herramientas.` : ''
-          } Pedile que continúe o subí \`maxRounds\`.`
+          }`
         );
       } else if (tools) {
         setText(turn.assistant(), '✓ El agente terminó sus herramientas, pero no devolvió un mensaje final.');
@@ -1639,6 +1693,7 @@ function handleChatEvent(event, data, turn) {
       }
     }
     renderCompletion(turn.active, data);
+    if (data.continuable) addContinueButton(turn, data);
     updateStatus({ rounds: data.rounds, stopReason: data.stopReason });
     addTokens(data.tokens);
   } else if (event === 'aborted') {
@@ -1679,6 +1734,7 @@ async function attachRun(sessionKey, pane) {
 async function sendMessage() {
   const current = state.panes.get(state.sessionId);
   if (current?.working) return;
+  hideSlashMenu();
   let input = chatInput.value.trim();
   const images = state.attachments.slice();
   if (input.startsWith('/') && !images.length) {
@@ -1778,11 +1834,13 @@ chatForm.addEventListener('submit', (event) => {
   sendMessage();
 });
 chatInput.addEventListener('keydown', (event) => {
+  if (handleSlashKey(event)) return;
   if (event.key === 'Enter' && !event.shiftKey) {
     event.preventDefault();
     sendMessage();
   }
 });
+chatInput.addEventListener('input', onChatInputChanged);
 
 /* --- image attachments ---------------------------------------------------- */
 
@@ -1956,6 +2014,99 @@ async function runCommand(name, arg) {
   }
 }
 
+/* --- menú de comandos "/" ------------------------------------------------- */
+
+const slashMenuEl = $('#slash-menu');
+let slashMatches = [];
+let slashIndex = 0;
+
+function slashCommandEntries() {
+  return COMMANDS.map(([cmd, desc]) => {
+    const name = cmd.split(' ')[0];
+    const takesArgs = cmd.includes(' ');
+    return { name, desc, insert: takesArgs ? `${name} ` : name, takesArgs };
+  });
+}
+
+function hideSlashMenu() {
+  if (!slashMenuEl) return;
+  slashMenuEl.hidden = true;
+  slashMenuEl.replaceChildren();
+  slashMatches = [];
+  slashIndex = 0;
+}
+
+function renderSlashMenu() {
+  if (!slashMenuEl) return;
+  slashMenuEl.replaceChildren();
+  slashMatches.forEach((entry, index) => {
+    const item = el('button', `slash-item${index === slashIndex ? ' active' : ''}`);
+    item.type = 'button';
+    item.append(el('span', 'slash-cmd', entry.name), el('span', 'slash-desc', entry.desc));
+    // mousedown (no click) para no perder el foco del textarea antes de elegir.
+    item.addEventListener('mousedown', (event) => {
+      event.preventDefault();
+      chooseSlash(index);
+    });
+    slashMenuEl.appendChild(item);
+  });
+  slashMenuEl.hidden = false;
+}
+
+function updateSlashMenu() {
+  if (!slashMenuEl) return;
+  const value = chatInput.value;
+  if (!value.startsWith('/') || /\s/.test(value)) return hideSlashMenu();
+  const query = value.slice(1).toLowerCase();
+  slashMatches = slashCommandEntries().filter((entry) => entry.name.slice(1).toLowerCase().startsWith(query));
+  if (!slashMatches.length) return hideSlashMenu();
+  if (slashIndex >= slashMatches.length) slashIndex = 0;
+  renderSlashMenu();
+}
+
+function chooseSlash(index) {
+  const entry = slashMatches[index];
+  if (!entry) return;
+  chatInput.value = entry.insert;
+  chatInput.focus();
+  hideSlashMenu();
+  if (!entry.takesArgs) sendMessage();
+}
+
+function handleSlashKey(event) {
+  if (!slashMenuEl || slashMenuEl.hidden || !slashMatches.length) return false;
+  if (event.key === 'ArrowDown') {
+    event.preventDefault();
+    slashIndex = (slashIndex + 1) % slashMatches.length;
+    renderSlashMenu();
+    return true;
+  }
+  if (event.key === 'ArrowUp') {
+    event.preventDefault();
+    slashIndex = (slashIndex - 1 + slashMatches.length) % slashMatches.length;
+    renderSlashMenu();
+    return true;
+  }
+  if (event.key === 'Escape') {
+    event.preventDefault();
+    hideSlashMenu();
+    return true;
+  }
+  if (event.key === 'Enter' || event.key === 'Tab') {
+    event.preventDefault();
+    chooseSlash(slashIndex);
+    return true;
+  }
+  return false;
+}
+
+function onChatInputChanged() {
+  slashIndex = 0;
+  updateSlashMenu();
+}
+
+chatInput.addEventListener('blur', () => setTimeout(hideSlashMenu, 120));
+
 /* --- folder picker -------------------------------------------------------- */
 
 const folderModal = $('#folder-modal');
@@ -2402,6 +2553,50 @@ const tgTranscribeEl = $('#tg-transcribe');
 const tgTranscribeProviderEl = $('#tg-transcribe-provider');
 const tgStatusEl = $('#tg-status');
 
+/* --- ajustes: pestañas internas + límites del agente --------------------- */
+
+const ajustesTabs = document.querySelectorAll('.ajustes-tab');
+
+function activateAjustesPanel(name) {
+  ajustesTabs.forEach((tab) => tab.classList.toggle('active', tab.dataset.panel === name));
+  document
+    .querySelectorAll('.ajustes-panel')
+    .forEach((panel) => panel.classList.toggle('active', panel.dataset.panel === name));
+  if (name === 'agente') moveAgentControls(agentControlsSlot);
+}
+
+ajustesTabs.forEach((tab) =>
+  tab.addEventListener('click', () => activateAjustesPanel(tab.dataset.panel))
+);
+
+const limitsRoundsEl = $('#limits-rounds');
+const limitsTokensEl = $('#limits-tokens');
+const limitsDurationEl = $('#limits-duration');
+
+async function refreshLimits() {
+  const data = await api('/api/settings').catch(() => null);
+  const settings = data?.settings;
+  if (!settings) return;
+  if (limitsRoundsEl) limitsRoundsEl.value = settings.maxRounds ?? 0;
+  if (limitsTokensEl) limitsTokensEl.value = settings.maxTokens ?? 0;
+  if (limitsDurationEl) limitsDurationEl.value = Math.round((settings.maxDurationMs ?? 0) / 1000);
+}
+
+$('#limits-save')?.addEventListener('click', async () => {
+  const body = {
+    maxRounds: Math.max(0, Number(limitsRoundsEl?.value) || 0),
+    maxTokens: Math.max(0, Number(limitsTokensEl?.value) || 0),
+    maxDurationMs: Math.max(0, Math.round((Number(limitsDurationEl?.value) || 0) * 1000)),
+  };
+  try {
+    await api('/api/settings', { method: 'PUT', body });
+    refreshLimits();
+    setStatus('#limits-msg', 'guardado', 'ok');
+  } catch (error) {
+    setStatus('#limits-msg', error.message, 'err');
+  }
+});
+
 function setStatus(node, text, cls = '') {
   const elNode = $(node);
   if (!elNode) return;
@@ -2443,6 +2638,8 @@ function syncMcpFormFields() {
   const http = $('#mf-transport').value === 'http';
   $('#mf-command-field').hidden = http;
   $('#mf-args-field').hidden = http;
+  $('#mf-env-field').hidden = http;
+  $('#mf-inherit-field').hidden = http;
   $('#mf-url-field').hidden = !http;
 }
 
@@ -2458,6 +2655,7 @@ function openMcpForm(server = null) {
   $('#mf-env').value = Object.entries(server?.env ?? {})
     .map(([key, value]) => `${key}=${value ?? ''}`)
     .join('\n');
+  $('#mf-inherit-env').checked = server?.inheritEnv === true;
   $('#mf-enabled').checked = server ? server.enabled !== false : true;
   syncMcpFormFields();
   setStatus('#mf-status', '');
@@ -2517,6 +2715,7 @@ async function submitMcp(event) {
     args: $('#mf-args').value.trim(),
     url: $('#mf-url').value.trim(),
     env: parseEnv($('#mf-env').value),
+    inheritEnv: $('#mf-inherit-env').checked,
     enabled: $('#mf-enabled').checked,
   };
   try {