@danieltmn/tamnora 0.25.0 → 0.26.0

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

@@ -1,12 +1,11 @@
 import { spawn } from 'node:child_process';
-import { readFileSync, statSync } from 'node:fs';
-import { bridgeStatePath } from './config/home.js';
-import { pidAlive, killPidTree } from './pid.js';
+import { killPidTree } from './pid.js';
 
 /**
- * Acceso remoto. Proveedores:
- *  - tailscale: VPN mesh privada + `tailscale serve` (recomendado; sin exposicion).
- *  - tunnelmole: tunel publico gratis (URL aleatoria); solo para `preview`.
+ * Acceso remoto por tailscale: VPN mesh privada + `tailscale serve`, que
+ * publica HTTPS dentro del tailnet reenviando a loopback. No hay proveedor
+ * publico: lo unico que sale de la maquina es lo que ya esta en la red privada
+ * del usuario.
  */
 
 function killTree(child) {
@@ -14,147 +13,11 @@ function killTree(child) {
   killPidTree(child.pid);
 }
 
-/**
- * Estado del bridge (escrito por `tamnora bridge`), si el supervisor sigue
- * vivo. Lo consulta el server para saber que hay un tunel publico activo y
- * ajustar el modelo de confianza (guards locales, cookie Secure).
- * Cache de 1 s + invalidacion por mtime del archivo: se lee en cada request
- * sensible, pero un bridge.json nuevo (o borrado) se ve al instante.
- */
-let tunnelCache = { key: null, mtime: null, at: 0, state: null };
-export function tunnelState() {
-  let statePath;
-  try {
-    statePath = bridgeStatePath();
-  } catch {
-    return null;
-  }
-  const now = Date.now();
-  let mtime = null;
-  try {
-    mtime = statSync(statePath).mtimeMs;
-  } catch {
-    tunnelCache = { key: statePath, mtime: null, at: now, state: null };
-    return null;
-  }
-  if (tunnelCache.key === statePath && tunnelCache.mtime === mtime && now - tunnelCache.at < 1000) {
-    return tunnelCache.state;
-  }
-  let state = null;
-  try {
-    const parsed = JSON.parse(readFileSync(statePath, 'utf8'));
-    // Tailscale es una red privada que entra por loopback: no es un tunel
-    // publico, asi que no debe degradar los guards locales (`localOk`).
-    if (parsed?.provider !== 'tailscale' && parsed?.pid && pidAlive(parsed.pid)) state = parsed;
-  } catch {
-    /* sin bridge */
-  }
-  tunnelCache = { key: statePath, mtime, at: now, state };
-  return state;
-}
-
-/** True si hay un tunel publico activo hacia este server. */
-export function tunnelActive() {
-  return Boolean(tunnelState());
-}
-
-export function parseTunnelmoleUrls(text) {
-  const urls = [...new Set(String(text).match(/https?:\/\/[a-z0-9-]+\.tunnelmole\.net/gi) || [])];
-  return {
-    https: urls.find((u) => u.startsWith('https')) || '',
-    http: urls.find((u) => u.startsWith('http:')) || '',
-  };
-}
-
-function spawnTunnel(bin, args, opts = {}) {
-  const log = opts.log || (() => {});
-  const parse = opts.parse || (() => ({ https: '', http: '' }));
-  const timeoutMs = opts.timeoutMs || 90000;
-  const label = opts.label || bin;
-  const useShell = process.platform === 'win32';
-  return new Promise((resolve, reject) => {
-    let child;
-    try {
-      // En Windows `npx` es un shim .cmd y exige shell; ahi se manda un unico
-      // comando (ver shellCommandLine): con array de args Node concatena sin
-      // escapar y emite el warning DEP0190.
-      const [cmd, cmdArgs] = useShell ? [shellCommandLine(bin, args), []] : [bin, args];
-      child = (opts.spawnImpl || spawn)(cmd, cmdArgs, {
-        stdio: ['ignore', 'pipe', 'pipe'],
-        windowsHide: true,
-        shell: useShell,
-        detached: !useShell,
-      });
-    } catch (err) {
-      reject(new Error(`no se pudo iniciar ${label}: ${err.message}`));
-      return;
-    }
-    let buf = '';
-    let settled = false;
-    const timer = setTimeout(() => {
-      if (settled) return;
-      settled = true;
-      killTree(child);
-      reject(new Error(`${label} no devolvio URL (${Math.round(timeoutMs / 1000)} s).`));
-    }, timeoutMs);
-    const feed = (data) => {
-      buf += String(data);
-      if (opts.verbose) process.stdout.write(String(data));
-      const urls = parse(buf);
-      const url = urls.https || urls.http;
-      if (url) {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
-        log(`${label}: ${url} -> localhost:${opts.port}`);
-        resolve({ url, provider: opts.provider, pid: child.pid, child, stop: () => killTree(child) });
-      }
-    };
-    child.stdout.on('data', feed);
-    child.stderr.on('data', feed);
-    child.on('error', (err) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      reject(new Error(`${label}: ${err.message}`));
-    });
-    child.on('exit', (code) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      reject(new Error(`${label} termino (codigo ${code})${buf ? `: ${buf.slice(0, 200).trim()}` : ''}`));
-    });
-  });
-}
-
-// Tunel publico para el feature `preview` (no lo usa `bridge`).
-export function startTunnelmole(port, opts = {}) {
-  return spawnTunnel('npx', ['--yes', 'tunnelmole', String(port)], {
-    ...opts,
-    port,
-    provider: 'tunnelmole',
-    label: 'tunnelmole',
-    parse: parseTunnelmoleUrls,
-  });
-}
-
 /**
  * Tailscale: VPN mesh (WireGuard). `tailscale serve` publica HTTPS dentro del
- * tailnet reenviando a loopback, asi que no hay exposicion publica y las
- * peticiones siguen siendo "locales" para el server. Proveedor recomendado.
+ * tailnet reenviando a loopback, asi que las peticiones siguen siendo "locales"
+ * para el server.
  */
-// Con `shell: true` Node concatena los args sin escapar (warning DEP0190): se
-// arma un unico comando con args validados contra metacaracteres del shell.
-const SAFE_SHELL_ARG = /^[^&|<>^%!"\r\n]+$/;
-
-function shellCommandLine(bin, args) {
-  for (const arg of args) {
-    if (!SAFE_SHELL_ARG.test(String(arg))) {
-      throw new Error(`argumento no permitido para ${bin}: "${arg}"`);
-    }
-  }
-  return [bin, ...args].join(' ');
-}
 
 function runTailscale(args, opts = {}) {
   const timeoutMs = opts.timeoutMs || 15000;
@@ -312,12 +175,11 @@ export function stopTailscaleServe(opts = {}) {
  * `opts.preview` usa el `serve` de un puerto HTTPS propio (8443) para no pisar el
  * bridge de la consola en 443.
  */
-export async function startTunnel(port, provider = 'tunnelmole', opts = {}) {
-  const p = String(provider || 'tunnelmole').toLowerCase();
+export async function startTunnel(port, provider = 'tailscale', opts = {}) {
+  const p = String(provider || 'tailscale').toLowerCase();
   if (p === 'none' || p === 'off' || p === '') return { url: '', provider: 'none', pid: 0, stop: () => {} };
   if (p === 'tailscale' || p === 'ts') {
     return opts.preview ? startTailscalePreview(port, opts) : startTailscaleServe(port, opts);
   }
-  if (p === 'tunnelmole' || p === 'tmole') return startTunnelmole(port, opts);
   throw new Error(`proveedor de tunel no soportado: ${provider}`);
 }

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

@@ -0,0 +1,111 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import {
+  AGENT_FILE,
+  parseAgentMarkdown,
+  loadAgents,
+  mergeAgents,
+  buildAgentsIndex,
+  buildSubagentPrompt,
+  writeAgentFile,
+} from '../src/agents/index.js';
+
+test('parseAgentMarkdown reads frontmatter, lists and the body', () => {
+  const parsed = parseAgentMarkdown(
+    '---\nname: Revisor\ndescription: Busca bugs\nmodel: claude\nprovider: anthropic\nmode: plan\neffort: high\nmaxRounds: 4\ntools: read, grep\nskills: [code-review, tests]\n---\n\n# Rol\nMirá el diff.',
+    'revisor'
+  );
+  assert.equal(parsed.id, 'revisor');
+  assert.equal(parsed.name, 'Revisor');
+  assert.equal(parsed.description, 'Busca bugs');
+  assert.equal(parsed.model, 'claude');
+  assert.equal(parsed.provider, 'anthropic');
+  assert.equal(parsed.mode, 'plan');
+  assert.equal(parsed.effort, 'high');
+  assert.equal(parsed.maxRounds, 4);
+  assert.deepEqual(parsed.tools, ['read', 'grep']);
+  assert.deepEqual(parsed.skills, ['code-review', 'tests']);
+  assert.match(parsed.body, /Mirá el diff/);
+
+  const plain = parseAgentMarkdown('Solo cuerpo.', 'x');
+  assert.equal(plain.name, 'x');
+  assert.equal(plain.tools, null);
+  assert.equal(plain.skills, null);
+  assert.equal(plain.body, 'Solo cuerpo.');
+});
+
+test('loadAgents scans directories and standalone .md files', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'tamnora-agents-'));
+  await mkdir(path.join(root, 'revisor'));
+  await writeFile(path.join(root, 'revisor', AGENT_FILE), '---\nname: Revisor\n---\nCuerpo.');
+  await writeFile(path.join(root, 'tests.md'), '---\nname: Tests\n---\nCuerpo tests.');
+  await writeFile(path.join(root, 'ignorado.txt'), 'no es un agente');
+
+  const agents = loadAgents(root);
+  assert.deepEqual(
+    agents.map((agent) => agent.id),
+    ['revisor', 'tests']
+  );
+  assert.equal(agents.find((agent) => agent.id === 'revisor').name, 'Revisor');
+  assert.equal(loadAgents(path.join(root, 'nope')).length, 0);
+});
+
+test('mergeAgents lets the workspace override the casa agent', async () => {
+  const home = await mkdtemp(path.join(tmpdir(), 'tamnora-agents-home-'));
+  const workspace = await mkdtemp(path.join(tmpdir(), 'tamnora-agents-ws-'));
+  await mkdir(path.join(home, 'demo'));
+  await writeFile(path.join(home, 'demo', AGENT_FILE), '---\nname: Demo casa\n---\nCasa.');
+  await mkdir(path.join(workspace, 'demo'));
+  await writeFile(path.join(workspace, 'demo', AGENT_FILE), '---\nname: Demo workspace\n---\nWorkspace.');
+
+  const merged = mergeAgents([loadAgents(home), loadAgents(workspace)]);
+  assert.equal(merged.length, 1);
+  assert.equal(merged[0].name, 'Demo workspace');
+});
+
+test('buildAgentsIndex catalogs subagents and buildSubagentPrompt includes instructions', () => {
+  assert.equal(buildAgentsIndex([]), '');
+  const index = buildAgentsIndex([
+    { id: 'revisor', name: 'Revisor', description: 'Busca bugs' },
+    { id: 'docs', name: 'Docs' },
+  ]);
+  assert.match(index, /task\(\{ agent: "<id>"/);
+  assert.match(index, /revisor: Revisor — Busca bugs/);
+  assert.match(index, /docs: Docs/);
+
+  const prompt = buildSubagentPrompt({ id: 'revisor', name: 'Revisor', description: 'Busca bugs', body: 'Mirá el diff.' }, { basePrompt: 'BASE' });
+  assert.match(prompt, /BASE/);
+  assert.match(prompt, /subagente "Revisor"/);
+  assert.match(prompt, /Mirá el diff\./);
+});
+
+test('writeAgentFile round-trips through parseAgentMarkdown', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'tamnora-agents-write-'));
+  await writeAgentFile(path.join(root, 'revisor'), {
+    id: 'revisor',
+    name: 'Revisor',
+    description: 'Busca bugs',
+    model: 'gpt',
+    provider: 'openai',
+    mode: 'plan',
+    effort: 'low',
+    maxRounds: 3,
+    tools: ['read'],
+    skills: null,
+    body: '# Rol\nMirá el diff.',
+  });
+  const text = await readFile(path.join(root, 'revisor', AGENT_FILE), 'utf8');
+  const parsed = parseAgentMarkdown(text, 'revisor');
+  assert.equal(parsed.name, 'Revisor');
+  assert.equal(parsed.effort, 'low');
+  assert.equal(parsed.maxRounds, 3);
+  assert.deepEqual(parsed.tools, ['read']);
+  assert.equal(parsed.skills, null);
+  assert.match(parsed.body, /Mirá el diff/);
+
+  await assert.rejects(() => writeAgentFile(path.join(root, '..'), { id: '../escape', body: 'x' }), /inválido/);
+});

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

@@ -1,18 +1,9 @@
 import { test, afterEach } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtemp, mkdir, writeFile, readFile } from 'node:fs/promises';
+import { mkdtemp, readFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
-import {
-  setHome,
-  homeDir,
-  homePath,
-  databaseFile,
-  ensureApp,
-  readApp,
-  writeApp,
-  migrateLegacyDb,
-} from '../src/index.js';
+import { setHome, homeDir, homePath, ensureApp, readApp, writeApp } from '../src/index.js';
 
 const prevHome = process.env.TAMNORA_HOME;
 
@@ -47,27 +38,3 @@ test('ensureApp creates app.json with a secret and roundtrips', async () => {
   writeApp(raw);
   assert.equal(readApp().port, 4599);
 });
-
-test('readApp migra los proveedores retirados (tunnelmole/relay) a tailscale', async () => {
-  const dir = await mkdtemp(path.join(tmpdir(), 'tamnora-home-'));
-  setHome(dir);
-  for (const provider of ['tunnelmole', 'relay']) {
-    const app = ensureApp();
-    app.tunnel = { ...app.tunnel, provider };
-    writeApp(app);
-    assert.equal(readApp().tunnel.provider, 'tailscale', provider);
-  }
-});
-
-test('migrateLegacyDb copies the legacy project database to the global home', async () => {
-  const home = await mkdtemp(path.join(tmpdir(), 'tamnora-home-'));
-  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-cwd-'));
-  setHome(home);
-
-  await mkdir(path.join(cwd, '.tamnora'), { recursive: true });
-  await writeFile(path.join(cwd, '.tamnora', 'tamnora.db'), 'legacy-db');
-
-  const target = migrateLegacyDb(cwd);
-  assert.equal(target, databaseFile());
-  assert.equal(await readFile(target, 'utf8'), 'legacy-db');
-});

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

@@ -5,7 +5,7 @@ import net from 'node:net';
 import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
-import { detectProcs, loadProjectProcs, packageManager, DEFAULT_PROCESS_ALLOW, PROCS_FILE } from '../src/procs/detect.js';
+import { loadProjectProcs, PROCS_FILE } from '../src/procs/project.js';
 import { killPort, portInfo } from '../src/procs/kill.js';
 
 async function waitForPort(port, attempts = 50) {
@@ -55,49 +55,9 @@ test('killPort terminates the process listening on a port', async (t) => {
   assert.ok(child.exitCode !== null || child.signalCode, 'el hijo debería haber terminado');
 });
 
-test('detectProcs finds node dev scripts with the right package manager', async () => {
+test('loadProjectProcs devuelve [] si el proyecto no declara procesos', async () => {
   const dir = await mkdtemp(path.join(tmpdir(), 'tamnora-proc-'));
-  await writeFile(path.join(dir, 'package.json'), JSON.stringify({ scripts: { dev: 'vite', test: 'x' } }));
-  await writeFile(path.join(dir, 'pnpm-lock.yaml'), '');
-  assert.equal(packageManager(dir), 'pnpm');
-
-  const chips = detectProcs(dir);
-  const dev = chips.find((c) => c.command === 'pnpm' && c.args.includes('dev'));
-  assert.ok(dev);
-  assert.equal(dev.cwd, dir);
-  assert.ok(DEFAULT_PROCESS_ALLOW.includes('pnpm'));
-});
-
-test('detectProcs falls back to npm and detects php entrypoints', async () => {
-  const nodeDir = await mkdtemp(path.join(tmpdir(), 'tamnora-proc-'));
-  await writeFile(path.join(nodeDir, 'package.json'), JSON.stringify({ scripts: { start: 'node app.js' } }));
-  assert.equal(packageManager(nodeDir), 'npm');
-  assert.ok(detectProcs(nodeDir).some((c) => c.command === 'npm' && c.args.includes('start')));
-
-  const phpDir = await mkdtemp(path.join(tmpdir(), 'tamnora-proc-'));
-  await mkdir(path.join(phpDir, 'public'));
-  await writeFile(path.join(phpDir, 'public', 'index.php'), '<?php');
-  const chips = detectProcs(phpDir);
-  const php = chips.find((c) => c.command === 'php');
-  assert.ok(php);
-  assert.equal(php.args[0], '-S');
-});
-
-test('detectProcs offers a static server for plain HTML sites', async () => {
-  const dir = await mkdtemp(path.join(tmpdir(), 'tamnora-proc-'));
-  await writeFile(path.join(dir, 'index.html'), '<h1>hola</h1>');
-  const chips = detectProcs(dir);
-  const staticChip = chips.find((c) => c.port && c.args.some((a) => a.endsWith('static-server.mjs')));
-  assert.ok(staticChip);
-  assert.equal(staticChip.cwd, dir);
-  assert.ok(staticChip.args.includes(dir));
-});
-
-test('detectProcs does not add the static chip when there is a dev script', async () => {
-  const dir = await mkdtemp(path.join(tmpdir(), 'tamnora-proc-'));
-  await writeFile(path.join(dir, 'index.html'), '<h1>hola</h1>');
-  await writeFile(path.join(dir, 'package.json'), JSON.stringify({ scripts: { dev: 'vite' } }));
-  assert.ok(!detectProcs(dir).some((c) => c.args.some((a) => String(a).endsWith('static-server.mjs'))));
+  assert.deepEqual(loadProjectProcs(dir), []);
 });
 
 test('loadProjectProcs reads .tamnora/procs.json and confines dir to the root', async () => {
@@ -124,27 +84,6 @@ test('loadProjectProcs reads .tamnora/procs.json and confines dir to the root',
   assert.ok(chips.every((c) => c.source === 'project'));
 });
 
-test('detectProcs puts project chips first and dedupes against auto-detection', async () => {
-  const dir = await mkdtemp(path.join(tmpdir(), 'tamnora-proc-'));
-  await mkdir(path.join(dir, '.tamnora'), { recursive: true });
-  await writeFile(path.join(dir, 'package.json'), JSON.stringify({ scripts: { dev: 'vite' } }));
-  await writeFile(
-    path.join(dir, PROCS_FILE),
-    JSON.stringify({
-      processes: [
-        { label: 'backend', command: 'node', args: ['server.js'], port: 3000 },
-        { label: 'dev repetido', command: 'npm', args: ['run', 'dev'] },
-      ],
-    })
-  );
-
-  const chips = detectProcs(dir);
-  assert.equal(chips[0].source, 'project');
-  assert.equal(chips[0].command, 'node');
-  const devChips = chips.filter((c) => c.command === 'npm' && c.args.join(' ') === 'run dev');
-  assert.equal(devChips.length, 1, 'el chip manual gana al autodetectado');
-});
-
 test('portInfo reports whether a port is listening', async (t) => {
   const free = await portInfo(47599);
   assert.equal(free.listening, false);

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

@@ -0,0 +1,43 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { normalizeEffort, applyReasoningEffort, EFFORT_LEVELS } from '../src/providers/reasoning.js';
+
+test('normalizeEffort accepts the common vocabulary and aliases', () => {
+  for (const level of EFFORT_LEVELS) assert.equal(normalizeEffort(level), level);
+  assert.equal(normalizeEffort(' HIGH '), 'high');
+  assert.equal(normalizeEffort('none'), 'off');
+  assert.equal(normalizeEffort('minimal'), 'low');
+  assert.equal(normalizeEffort('xhigh'), 'max');
+  assert.equal(normalizeEffort('ultra'), 'max');
+  assert.equal(normalizeEffort('auto'), '');
+  assert.equal(normalizeEffort(''), '');
+  assert.equal(normalizeEffort(null), '');
+  assert.equal(normalizeEffort('inventado'), '');
+});
+
+test('applyReasoningEffort maps the level to each provider shape', () => {
+  const deepseek = applyReasoningEffort({}, 'high', { reasoning: 'deepseek' });
+  assert.equal(deepseek.reasoning_effort, 'high');
+  assert.deepEqual(deepseek.thinking, { type: 'enabled' });
+
+  const off = applyReasoningEffort({}, 'off', { reasoning: 'deepseek' });
+  assert.equal(off.reasoning_effort, 'none');
+  assert.deepEqual(off.thinking, { type: 'disabled' });
+
+  const openai = applyReasoningEffort({}, 'max', { reasoning: 'openai' });
+  assert.equal(openai.reasoning_effort, 'high', 'OpenAI no llega a max');
+
+  const openrouter = applyReasoningEffort({}, 'max', { reasoning: 'effort' });
+  assert.equal(openrouter.reasoning_effort, 'max');
+
+  const ollama = applyReasoningEffort({}, 'low', { reasoning: 'think' });
+  assert.equal(ollama.think, 'low');
+  const ollamaOff = applyReasoningEffort({}, 'off', { reasoning: 'think' });
+  assert.equal(ollamaOff.think, false);
+});
+
+test('applyReasoningEffort leaves unsupported providers untouched', () => {
+  assert.deepEqual(applyReasoningEffort({ model: 'x' }, 'high', { reasoning: 'none' }), { model: 'x' });
+  assert.deepEqual(applyReasoningEffort({ model: 'x' }, 'high', {}), { model: 'x' });
+  assert.deepEqual(applyReasoningEffort({ model: 'x' }, '', { reasoning: 'effort' }), { model: 'x' });
+});

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

@@ -2,7 +2,7 @@ import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { Store } from '../src/storage/sqlite.js';
 
-test('Store persists sessions, messages and runs', () => {
+test('Store persists sessions and messages', () => {
   const store = new Store(':memory:');
 
   const sessionId = store.createSession({ title: 'test', provider: 'openrouter', model: 'm' });
@@ -27,17 +27,6 @@ test('Store persists sessions, messages and runs', () => {
 
   assert.equal(store.latestSession().id, sessionId);
 
-  const runId = store.createRun({ dataset: 'd.jsonl', config: { models: ['m'] } });
-  store.addRunResult({ runId, taskId: 't1', model: 'm', passed: true, output: 'ok' });
-  store.finishRun(runId, { summary: { total: 1 } });
-
-  const run = store.getRun(runId);
-  assert.equal(run.status, 'done');
-  assert.equal(run.summary.total, 1);
-  const results = store.getRunResults(runId);
-  assert.equal(results.length, 1);
-  assert.equal(results[0].passed, 1);
-
   store.close();
 });
 

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

@@ -26,12 +26,16 @@ import {
   agentControlsSlot,
   buildAppearanceControls,
   closeCreateFolder,
+  closeEffortMenu,
   closeFolderPicker,
   closeModeMenu,
   closeSettingsModal,
   createFolder,
   cwdPill,
   cycleTheme,
+  effortMenu,
+  effortPill,
+  effortSelect,
   filterFolders,
   folderGoto,
   folderList,
@@ -60,6 +64,7 @@ import {
   providerSelect,
   renderModePill,
   setCwd,
+  setEffort,
   setMode,
   settingsModal,
   statusbarEl,
@@ -87,7 +92,7 @@ import {
   PREVIEW_DEVICE_KEY,
   PREVIEW_URL_KEY,
   applyTreeFilter,
-  detectProcs,
+  loadProcChips,
   explorerFilter,
   explorerMode,
   filePreviewState,
@@ -114,6 +119,9 @@ import { wireModelPicker } from './models.js';
 import { restoreTabs, startNewSession } from './sessions.js';
 import {
   addPerfilFieldRow,
+  agentForm,
+  agentModal,
+  closeAgentForm,
   closeMcpForm,
   closeMemoryForm,
   closeProviderForm,
@@ -133,6 +141,7 @@ import {
   mcpPinnedEl,
   memoryForm,
   memoryModal,
+  openAgentForm,
   openMcpForm,
   openMemoryForm,
   openProviderForm,
@@ -155,7 +164,7 @@ import {
   setStatus,
   skillForm,
   skillModal,
-  submitAsesor,
+  submitAgent,
   submitChannel,
   submitMcp,
   submitMemory,
@@ -164,7 +173,6 @@ import {
   submitSchedule,
   submitSkill,
   syncMcpFormFields,
-  testAsesor,
   testChannel,
   testProvider,
   vozPitchEl,
@@ -174,15 +182,11 @@ import {
 import {
   brandVerEl,
   dismissUpdate,
-  evalRunBtn,
-  evalTasks,
   followEvents,
   forceUpdateCheck,
   reconcile,
-  refreshRuns,
   refreshUpdate,
   renderAlertSignals,
-  runEval,
   runUpdate,
   watchLifecycle,
 } from './system.js';
@@ -335,6 +339,25 @@ document.addEventListener('keydown', (event) => {
   if (event.key === 'Escape') closeModeMenu();
 });
 modelPill?.addEventListener('click', () => openSettingsModal());
+effortPill?.addEventListener('click', (event) => {
+  event.stopPropagation();
+  if (!effortMenu) return;
+  effortMenu.hidden = !effortMenu.hidden;
+  effortPill.setAttribute('aria-expanded', effortMenu.hidden ? 'false' : 'true');
+});
+effortMenu?.addEventListener('click', async (event) => {
+  const item = event.target.closest('.ctrl-menu-item');
+  if (!item) return;
+  closeEffortMenu();
+  await setEffort(item.dataset.effort || '');
+});
+effortSelect?.addEventListener('change', () => setEffort(effortSelect.value));
+document.addEventListener('click', (event) => {
+  if (effortMenu && !effortMenu.hidden && !event.target.closest('.ctrl-wrap')) closeEffortMenu();
+});
+document.addEventListener('keydown', (event) => {
+  if (event.key === 'Escape') closeEffortMenu();
+});
 yesInput?.addEventListener('change', renderModePill);
 strictInput?.addEventListener('change', () =>
   api('/api/settings', { method: 'PUT', body: { strictScope: strictInput.checked } }).catch(() => null)
@@ -619,8 +642,6 @@ $('#voz-save')?.addEventListener('click', submitVoz);
 $('#voz-test')?.addEventListener('click', testVoz);
 vozRateEl?.addEventListener('input', renderVozSliders);
 vozPitchEl?.addEventListener('input', renderVozSliders);
-$('#asesor-save')?.addEventListener('click', submitAsesor);
-$('#asesor-test')?.addEventListener('click', testAsesor);
   $('#mcp-close').addEventListener('click', closeMcpForm);
   $('#mf-cancel').addEventListener('click', closeMcpForm);
   $('#mf-transport').addEventListener('change', syncMcpFormFields);
@@ -637,6 +658,14 @@ $('#asesor-test')?.addEventListener('click', testAsesor);
     if (event.target === skillModal) closeSkillForm();
   });
 
+  $('#agent-new')?.addEventListener('click', () => openAgentForm());
+  $('#agent-close')?.addEventListener('click', closeAgentForm);
+  $('#af-cancel')?.addEventListener('click', closeAgentForm);
+  agentForm?.addEventListener('submit', submitAgent);
+  agentModal?.addEventListener('click', (event) => {
+    if (event.target === agentModal) closeAgentForm();
+  });
+
   $('#memory-new')?.addEventListener('click', () => openMemoryForm());
   $('#memory-close')?.addEventListener('click', closeMemoryForm);
   $('#mem-cancel')?.addEventListener('click', closeMemoryForm);
@@ -656,15 +685,6 @@ $('#asesor-test')?.addEventListener('click', testAsesor);
   });
 }
 
-evalTasks.value = [
-  '{"id":"math","input":"¿Cuánto es 17 * 23? Respondé solo el número.","expect":{"equals":"391"}}',
-  '{"id":"regex","input":"Escribí una oración que contenga un número.","expect":{"regex":"\\\\d"}}',
-].join('\n');
-
-evalRunBtn.addEventListener('click', runEval);
-
-$('#runs-refresh').addEventListener('click', refreshRuns);
-
 $('#file-preview-toggle')?.addEventListener('click', async () => {
   const toggle = $('#file-preview-toggle');
   const code = $('#file-code');
@@ -759,7 +779,7 @@ $('#preview-device')?.addEventListener('change', (event) => storage.set(PREVIEW_
   syncPreviewTunnel({ load: true });
 })();
 
-$('#procs-detect')?.addEventListener('click', detectProcs);
+$('#procs-detect')?.addEventListener('click', loadProcChips);
 
 gitFilterEl?.addEventListener('input', () => {
   if (explorerMode === 'git' && gitEntries.length) renderGitList();